wip status while recording

Dirty code, missing proper exceptions catching,
permissions etc.

Try to deploy it on staging, see if email are sent.

.github/workflows/deploy.yml

@@ -0,0 +1,52 @@
+name: Deploy
+
+on:
+  push:
+    tags:
+      - 'preprod'
+      - 'production'
+
+
+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 ''${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:
+      - notify-argocd
+    runs-on: ubuntu-latest
+    if: startsWith(github.event.ref, 'refs/tags/preprod')
+    steps:
+      -
+        name: Debug
+        run: |
+          echo "Start test when preprod is ready"

.github/workflows/docker-hub.yml

@@ -1,5 +1,4 @@
 name: Docker Hub Workflow
-run-name: Docker Hub Workflow
 
 on:
   workflow_dispatch:
@@ -19,9 +18,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,16 +47,10 @@ 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
-      -
-        name: Run trivy scan
-        uses: numerique-gouv/action-trivy-cache@main
-        with:
-          docker-build-args: '--target backend-production -f Dockerfile'
-          docker-image-name: 'docker.io/lasuite/meet-backend:${{ github.sha }}'
+        run: echo "$DOCKER_HUB_PASSWORD" | docker login -u "$DOCKER_HUB_USER" --password-stdin
       -
         name: Build and push
-        uses: docker/build-push-action@v6
+        uses: docker/build-push-action@v5
         with:
           context: .
           target: backend-production
@@ -49,12 +59,29 @@ jobs:
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
 
-  build-and-push-frontend-generic:
+  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,16 +91,10 @@ 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
-      -
-        name: Run trivy scan
-        uses: numerique-gouv/action-trivy-cache@main
-        with:
-          docker-build-args: '-f src/frontend/Dockerfile --target frontend-production'
-          docker-image-name: 'docker.io/lasuite/meet-frontend:${{ github.sha }}'
+        run: echo "$DOCKER_HUB_PASSWORD" | docker login -u "$DOCKER_HUB_USER" --password-stdin
       -
         name: Build and push
-        uses: docker/build-push-action@v6
+        uses: docker/build-push-action@v5
         with:
           context: .
           file: ./src/frontend/Dockerfile
@@ -83,80 +104,37 @@ jobs:
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
 
-  build-and-push-frontend-dinum:
-    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-frontend-dinum
-      -
-        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: Run trivy scan
-        uses: numerique-gouv/action-trivy-cache@main
-        with:
-          docker-build-args: '-f docker/dinum-frontend/Dockerfile --target frontend-production'
-          docker-image-name: 'docker.io/lasuite/meet-frontend-dinum:${{ github.sha }}'
-      -
-        name: Build and push
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          file: ./docker/dinum-frontend/Dockerfile
-          target: frontend-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 }}
-
-  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-generic
-      - build-and-push-frontend-dinum
+      - 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: numerique-gouv/action-argocd-webhook-notification@main
-        id: notify
+      -
+        uses: actions/create-github-app-token@v1
+        id: app-token
         with:
-          deployment_repo_path: "${{ secrets.DEPLOYMENT_REPO_URL }}"
-          argocd_webhook_secret: "${{ secrets.ARGOCD_PREPROD_WEBHOOK_SECRET }}"
-          argocd_url: "${{ vars.ARGOCD_PREPROD_WEBHOOK_URL }}"
+          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 ''${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/meet.yml

@@ -81,7 +81,7 @@ jobs:
       - name: Install Python
         uses: actions/setup-python@v5
         with:
-          python-version: "3.13"
+          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,13 +121,9 @@ 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
-      AWS_S3_ENDPOINT_URL: http://localhost:9000
-      AWS_S3_ACCESS_KEY_ID: meet
-      AWS_S3_SECRET_ACCESS_KEY: password
 
     steps:
       - name: Checkout repository
@@ -155,37 +141,10 @@ jobs:
           path: "src/backend/core/templates/mail"
           key: mail-templates-${{ hashFiles('src/mail/mjml') }}
 
-      - name: Start MinIO
-        run: |
-          docker pull minio/minio
-          docker run -d --name minio \
-            -p 9000:9000 \
-            -e "MINIO_ACCESS_KEY=meet" \
-            -e "MINIO_SECRET_KEY=password" \
-            -v /data/media:/data \
-            minio/minio server --console-address :9001 /data
-
-      # Tool to wait for a service to be ready
-      - name: Install Dockerize
-        run: |
-          curl -sSL https://github.com/jwilder/dockerize/releases/download/v0.8.0/dockerize-linux-amd64-v0.8.0.tar.gz | sudo tar -C /usr/local/bin -xzv
-
-      - name: Wait for MinIO to be ready
-        run: |
-          dockerize -wait tcp://localhost:9000 -timeout 10s
-
-      - name: Configure MinIO
-        run: |
-          MINIO=$(docker ps | grep minio/minio | sed -E 's/.*\s+([a-zA-Z0-9_-]+)$/\1/')
-          docker exec ${MINIO} sh -c \
-            "mc alias set meet http://localhost:9000 meet password && \
-            mc alias ls && \
-            mc mb meet/meet-media-storage"
-
       - name: Install Python
         uses: actions/setup-python@v5
         with:
-          python-version: "3.13"
+          python-version: "3.10"
 
       - name: Install development dependencies
         run: pip install --user .[dev]
@@ -216,36 +175,69 @@ jobs:
       - name: Check format
         run: cd src/frontend/ && npm run check
 
-  lint-sdk:
+  i18n-crowdin:
     runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: src/sdk/library
     steps:
-      - name: Checkout repository
+      -
+        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
         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: Install gettext (required to make messages)
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y gettext
+
+      - name: Install Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+
+      - name: Install development dependencies
+        working-directory: src/backend
+        run: pip install --user .[dev]
+
+      - name: Generate the translation base file
+        run: ~/.local/bin/django-admin makemessages --keep-pot --all
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "18.x"
+          cache: "npm"
+          cache-dependency-path: src/frontend/package-lock.json
 
       - name: Install dependencies
-        run: npm ci
+        run: cd src/frontend/ && npm ci
 
-      - name: Check linting
-        run: npm run lint
+      - name: Extract the frontend translation
+        run: make frontend-i18n-extract
 
-      - 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
+      - name: Upload files to Crowdin
+        uses: crowdin/github-action@v2
+        with:
+          config: crowdin/config.yml
+          upload_sources: true
+          upload_translations: true
+          download_translations: false
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          CROWDIN_PROJECT_ID: ${{ secrets.CROWDIN_PROJECT_ID }}
+          CROWDIN_BASE_PATH: ${{ github.workspace }}
+          CROWDIN_PERSONAL_TOKEN: ${{ secrets.CROWDIN_PERSONAL_TOKEN }}

.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

.sops.yaml

@@ -8,5 +8,3 @@ creation_rules:
       - age1tl80n23wq6zxegupwn70ew0yp225ua5v4dk800x7g2w6pvlxz46qk592pa #marie
       - age1qy04neuzwpasmvljqrcvhwnf0kz5cpyteze38c8avp0czewskasszv9pyw #argocd
       - age18fgn6j2vwwswqcpv9xpcehq8mrf9zs2sglwkamp3tzwx8d9jq9jsrskrk9 #manuuu
-      - age1hm2hsfgjezpsc3k0y5w5feq9t8vl3seq04qjhgt6ztd6403wfvpsgxu09m # github-repo
-      - age1hnhuzj96ktkhpyygvmz0x9h8mfvssz7ss6emmukags644mdhf4msajk93r # Samuel Paccoud

CHANGELOG.md

@@ -1,4 +1,3 @@
-
 # Changelog
 
 All notable changes to this project will be documented in this file.
@@ -8,5 +7,3 @@ and this project adheres to
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
-
-- 🔧(backend) support `_FILE` for secret environment variables #566 

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! 👍

Dockerfile

@@ -1,17 +1,18 @@
 # Django Meet
 
 # ---- base image to inherit from ----
-FROM python:3.13.5-alpine3.21 AS base
+FROM python:3.10-slim-bullseye as base
 
 # Upgrade pip to its latest release to speed up dependencies installation
-RUN python -m pip install --upgrade pip setuptools
+RUN python -m pip install --upgrade pip
 
 # Upgrade system packages to install security updates
-RUN apk update && \
-  apk upgrade
+RUN apt-get update && \
+  apt-get -y upgrade && \
+  rm -rf /var/lib/apt/lists/*
 
 # ---- Back-end builder image ----
-FROM base AS back-builder
+FROM base as back-builder
 
 WORKDIR /builder
 
@@ -23,7 +24,7 @@ RUN mkdir /install && \
 
 
 # ---- mails ----
-FROM node:20 AS mail-builder
+FROM node:20 as mail-builder
 
 COPY ./src/mail /mail/app
 
@@ -34,12 +35,15 @@ RUN yarn install --frozen-lockfile && \
 
 
 # ---- static link collector ----
-FROM base AS link-collector
+FROM base as link-collector
 ARG MEET_STATIC_ROOT=/data/static
 
-RUN apk add \
-  pango \
-  rdfind
+# Install libpangocairo & rdfind
+RUN apt-get update && \
+    apt-get install -y \
+      libpangocairo-1.0-0 \
+      rdfind && \
+    rm -rf /var/lib/apt/lists/*
 
 # Copy installed python dependencies
 COPY --from=back-builder /install /usr/local
@@ -58,18 +62,21 @@ RUN DJANGO_CONFIGURATION=Build DJANGO_JWT_PRIVATE_SIGNING_KEY=Dummy \
 RUN rdfind -makesymlinks true -followsymlinks true -makeresultsfile false ${MEET_STATIC_ROOT}
 
 # ---- Core application image ----
-FROM base AS core
+FROM base as core
 
 ENV PYTHONUNBUFFERED=1
 
-RUN apk --no-cache add \
-  cairo \
-  gdk-pixbuf \
-  gettext \
-  libffi-dev \
-  pango \
-  shared-mime-info
-
+# Install required system libs
+RUN apt-get update && \
+    apt-get install -y \
+      gettext \
+      libcairo2 \
+      libffi-dev \
+      libgdk-pixbuf2.0-0 \
+      libpango-1.0-0 \
+      libpangocairo-1.0-0 \
+      shared-mime-info && \
+  rm -rf /var/lib/apt/lists/*
 
 # Copy entrypoint
 COPY ./docker/files/usr/local/bin/entrypoint /usr/local/bin/entrypoint
@@ -93,13 +100,15 @@ WORKDIR /app
 ENTRYPOINT [ "/usr/local/bin/entrypoint" ]
 
 # ---- Development image ----
-FROM core AS backend-development
+FROM core as backend-development
 
 # Switch back to the root user to install development dependencies
 USER root:root
 
 # Install psql
-RUN apk add postgresql-client
+RUN apt-get update && \
+    apt-get install -y postgresql-client && \
+    rm -rf /var/lib/apt/lists/*
 
 # Uninstall Meet and re-install it in editable mode along with development
 # dependencies
@@ -119,7 +128,7 @@ ENV DB_HOST=postgresql \
 CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]
 
 # ---- Production image ----
-FROM core AS backend-production
+FROM core as backend-production
 
 ARG MEET_STATIC_ROOT=/data/static
 

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024-2025 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) 2024-2025 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,18 +301,7 @@ build-k8s-cluster: ## build the kubernetes cluster using kind
 	./bin/start-kind.sh
 .PHONY: build-k8s-cluster
 
-install-external-secrets: ## install the kubernetes secrets from Vaultwarden
-	./bin/install-external-secrets.sh
-.PHONY: build-k8s-cluster
-
 start-tilt: ## start the kubernetes cluster using kind
 	tilt up -f ./bin/Tiltfile
 .PHONY: build-k8s-cluster
 
-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
-
-start-tilt-dinum: ## start the kubernetes cluster using kind, without Pro Connect for authentication, but with DINUM styles
-	DEV_ENV=dev-dinum tilt up -f ./bin/Tiltfile
-.PHONY: build-k8s-cluster

README.md

@@ -1,120 +1,155 @@
-<p align="center">
-  <img alt="meet logo" src="./docs/assets/banner-meet-fr.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://matrix.to/#/#meet-official:matrix.org">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="La Suite Meet Demonstration">
-  </a>
-</p>
+```bash
+$ make demo
+```
 
-## La Suite Meet: Simple Video Conferencing
+Finally, you can check all available Make rules using:
 
-Powered by [LiveKit](https://livekit.io/), La Suite Meet 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
-- Meeting transcription (currently in beta)
-- Telephony integration
-- 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`.
 
 
-La Suite Meet 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`:
 
-### La Suite Meet Cloud (Recommended)
-Sign up for La Suite Meet Cloud, designed for french 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 La Suite Meet 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 La Suite Meet. 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 La Suite Meet 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—La Suite Meet. Growth comes from creating something people truly need, not just from chasing metrics.
-
-Our users come first. We’re committed to making La Suite Meet 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 La Suite Meet 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 tested with BrowserStack.
+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,18 +2,6 @@ load('ext://uibutton', 'cmd_button', 'bool_input', 'location')
 load('ext://namespace', 'namespace_create', 'namespace_inject')
 namespace_create('meet')
 
-DEV_ENV = os.getenv('DEV_ENV', 'dev')
-
-if DEV_ENV == 'dev-dinum':
-    update_settings(suppress_unused_image_warnings=["localhost:5001/meet-frontend-generic:latest"])
-
-if DEV_ENV == 'dev-keycloak':
-    update_settings(suppress_unused_image_warnings=["localhost:5001/meet-frontend-dinum:latest"])
-
-
-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='..',
@@ -28,22 +16,9 @@ docker_build(
         )
     ]
 )
-clean_old_images('localhost:5001/meet-backend')
 
 docker_build(
-    'localhost:5001/meet-frontend-dinum:latest',
-    context='..',
-    dockerfile='../docker/dinum-frontend/Dockerfile',
-    only=['./src/frontend', './docker', './.dockerignore'],
-    target = 'frontend-production',
-    live_update=[
-        sync('../src/frontend', '/home/frontend'),
-    ]
-)
-clean_old_images('localhost:5001/meet-frontend-dinum')
-
-docker_build(
-    'localhost:5001/meet-frontend-generic:latest',
+    'localhost:5001/meet-frontend:latest',
     context='..',
     dockerfile='../src/frontend/Dockerfile',
     only=['./src/frontend', './docker', './.dockerignore'],
@@ -52,38 +27,8 @@ docker_build(
         sync('../src/frontend', '/home/frontend'),
     ]
 )
-clean_old_images('localhost:5001/meet-frontend-generic')
 
-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 -f "$(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,103 @@
-#!/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
+
+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,13 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-HELMFILE=src/helm/helmfile.yaml
-
-environments=$(awk '/environments:/ {flag=1; next} flag && NF {print} !NF {flag=0}' "$HELMFILE" | grep -E '^[[:space:]]{2}[a-zA-Z]+' | sed 's/^[[:space:]]*//;s/:.*//')
-
-for env in $environments; do
-	echo "################### $env lint ###################"
-	helmfile -e $env -f src/helm/helmfile.yaml lint || exit 1
-	echo -e "\n"
-done

docker-compose.yml

@@ -1,3 +1,4 @@
+version: '3.8'
 
 services:
   postgresql:
@@ -15,37 +16,6 @@ services:
     ports:
       - "1081:1080"
 
-  minio:
-    user: ${DOCKER_USER:-1000}
-    image: minio/minio
-    environment:
-      - MINIO_ROOT_USER=meet
-      - MINIO_ROOT_PASSWORD=password
-    ports:
-      - '9000:9000'
-      - '9001:9001'
-    healthcheck:
-      test: [ "CMD", "mc", "ready", "local" ]
-      interval: 1s
-      timeout: 20s
-      retries: 300
-    entrypoint: ""
-    command: minio server --console-address :9001 /data
-    volumes:
-      - ./data/media:/data
-
-  createbuckets:
-    image: minio/mc
-    depends_on:
-      minio:
-        condition: service_healthy
-        restart: true
-    entrypoint: >
-      sh -c "
-      /usr/bin/mc alias set meet http://minio:9000 meet password && \
-      /usr/bin/mc mb meet/meet-media-storage && \
-      exit 0;"
-
   app-dev:
     build:
       context: .
@@ -71,9 +41,6 @@ services:
         - redis
         - nginx
         - livekit
-        - createbuckets
-    extra_hosts:
-      - "127.0.0.1.nip.io:host-gateway"
   
   celery-dev:
     user: ${DOCKER_USER:-1000}
@@ -107,7 +74,6 @@ services:
       - postgresql
       - redis
       - livekit
-      - minio
 
   celery:
     user: ${DOCKER_USER:-1000}
@@ -130,22 +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"
-        VITE_APP_TITLE: "LaSuite Meet"
-    image: meet:frontend-development
-    ports:
-      - "3000:8080"
-
   dockerize:
     image: jwilder/dockerize
-    platform: linux/x86_64
 
   crowdin:
     image: crowdin/cli:4.0.0

docker/dinum-frontend/Dockerfile

@@ -1,62 +0,0 @@
-# ---- Front-end image ----
-FROM node:20-alpine AS frontend-deps
-
-WORKDIR /home/frontend/
-
-COPY ./src/frontend/package.json ./package.json
-COPY ./src/frontend/package-lock.json ./package-lock.json
-
-RUN npm ci
-
-COPY .dockerignore ./.dockerignore
-COPY ./src/frontend/ .
-
-# ---- Front-end builder image ----
-FROM frontend-deps AS meet-builder
-
-WORKDIR /home/frontend
-
-ENV VITE_APP_TITLE="Visio"
-ENV VITE_BUILD_SOURCEMAP="true"
-
-RUN npm run build
-
-# Inject PostHog sourcemap metadata into the built assets
-# This metadata is essential for correctly mapping errors to source maps in production
-RUN set -e && \
-    npx @posthog/cli sourcemap inject --directory ./dist/assets
-
-COPY ./docker/dinum-frontend/dinum-styles.css \
-    ./dist/assets/
-
-COPY ./docker/dinum-frontend/logo.svg \
-    ./dist/assets/logo.svg
-
-COPY ./docker/dinum-frontend/assets/ \
-    ./dist/assets/
-
-COPY ./docker/dinum-frontend/fonts/ \
-    ./dist/assets/fonts/
-
-# ---- Front-end image ----
-FROM nginxinc/nginx-unprivileged:alpine3.21 AS frontend-production
-
-USER root
-RUN apk update && apk upgrade libssl3 libcrypto3 libxml2>=2.12.7-r2 libxslt>=1.1.39-r2
-
-USER nginx
-
-# Un-privileged user running the application
-ARG DOCKER_USER
-USER ${DOCKER_USER}
-
-COPY --from=meet-builder \
-    /home/frontend/dist \
-    /usr/share/nginx/html
-
-COPY ./src/frontend/default.conf /etc/nginx/conf.d
-COPY ./docker/files/usr/local/bin/entrypoint /usr/local/bin/entrypoint
-
-ENTRYPOINT [ "/usr/local/bin/entrypoint" ]
-
-CMD ["nginx", "-g", "daemon off;"]

docker/dinum-frontend/assets/gouvernement.svg

@@ -1,61 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!-- Created with Inkscape (http://www.inkscape.org/) -->
-
-<svg
-   width="38.194309mm"
-   height="3.4877367mm"
-   viewBox="0 0 38.194309 3.4877367"
-   version="1.1"
-   id="svg1"
-   sodipodi:docname="gouvernement.svg"
-   inkscape:version="1.4.1 (93de688d07, 2025-03-30)"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:svg="http://www.w3.org/2000/svg">
-  <sodipodi:namedview
-     id="namedview1"
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1.0"
-     inkscape:showpageshadow="2"
-     inkscape:pageopacity="0.0"
-     inkscape:pagecheckerboard="0"
-     inkscape:deskcolor="#d1d1d1"
-     inkscape:document-units="mm"
-     inkscape:zoom="6.1918409"
-     inkscape:cx="79.620909"
-     inkscape:cy="44.332534"
-     inkscape:window-width="1901"
-     inkscape:window-height="1037"
-     inkscape:window-x="5"
-     inkscape:window-y="5"
-     inkscape:window-maximized="0"
-     inkscape:current-layer="layer1" />
-  <defs
-     id="defs1">
-    <rect
-       x="111.07374"
-       y="333.22122"
-       width="541.4845"
-       height="297.51895"
-       id="rect2" />
-    <rect
-       x="158.10136"
-       y="358.3631"
-       width="425.55618"
-       height="204.21426"
-       id="rect1" />
-  </defs>
-  <g
-     inkscape:label="Layer 1"
-     inkscape:groupmode="layer"
-     id="layer1"
-     transform="translate(-53.656101,-100.08408)">
-    <path
-       d="m 55.435527,103.08144 c -0.72898,0 -1.249045,-0.56007 -1.249045,-1.25349 0,-0.69342 0.502285,-1.25349 1.204595,-1.25349 0.41783,0 0.760095,0.20447 0.96901,0.50673 l 0.333375,-0.25781 c -0.28448,-0.38227 -0.742315,-0.64008 -1.302385,-0.64008 -0.973455,0 -1.63576,0.75565 -1.63576,1.64465 0,0.889 0.680085,1.64465 1.68021,1.64465 0.582295,0 1.05791,-0.24892 1.346835,-0.64008 v -1.21349 h -1.31572 v 0.36005 h 0.89789 v 0.70231 c -0.217805,0.24447 -0.54229,0.40005 -0.929005,0.40005 z m 3.569334,-2.89814 c -0.973455,0 -1.63576,0.75565 -1.63576,1.64465 0,0.889 0.662305,1.64465 1.63576,1.64465 0.96901,0 1.631315,-0.75565 1.631315,-1.64465 0,-0.889 -0.662305,-1.64465 -1.631315,-1.64465 z m 0,2.89814 c -0.70231,0 -1.204595,-0.56007 -1.204595,-1.25349 0,-0.69342 0.502285,-1.25349 1.204595,-1.25349 0.697865,0 1.20015,0.56007 1.20015,1.25349 0,0.69342 -0.502285,1.25349 -1.20015,1.25349 z m 4.276088,-0.84455 c 0,0.53784 -0.31115,0.84455 -0.786765,0.84455 -0.48006,0 -0.79121,-0.30671 -0.79121,-0.84455 v -1.96469 h -0.41783 v 1.93802 c 0,0.8001 0.48006,1.26238 1.20904,1.26238 0.72898,0 1.204595,-0.46228 1.204595,-1.26238 v -1.93802 h -0.41783 z m 0.942341,-1.96469 1.2446,3.1115 h 0.55118 l 1.2446,-3.1115 h -0.4445 l -1.07569,2.68922 -1.07569,-2.68922 z m 3.653795,3.1115 h 1.67132 v -0.3556 h -1.25349 v -1.05347 h 1.07569 v -0.35115 h -1.07569 v -0.99568 h 1.25349 v -0.3556 h -1.67132 z m 2.502533,0 h 0.41783 v -1.36462 h 0.40894 c 0.03111,0 0.06667,0 0.09779,-0.004 l 0.902335,1.36906 h 0.493395 l -1.00457,-1.44907 c 0.333375,-0.13335 0.52451,-0.41339 0.52451,-0.78677 0,-0.5334 -0.386715,-0.87566 -1.01346,-0.87566 h -0.82677 z m 0.84455,-2.7559 c 0.3556,0 0.564515,0.19558 0.564515,0.51117 0,0.33338 -0.208915,0.52451 -0.564515,0.52451 h -0.42672 v -1.03568 z m 2.004699,2.7559 h 0.41783 v -2.60033 l 1.76022,2.60033 h 0.546735 v -3.1115 h -0.41783 v 2.60032 l -1.76022,-2.60032 h -0.546735 z m 3.71158,0 h 1.67132 v -0.3556 h -1.25349 v -1.05347 h 1.07569 v -0.35115 h -1.07569 v -0.99568 h 1.25349 v -0.3556 h -1.67132 z m 2.502533,0 h 0.41783 v -2.55143 l 0.90678,1.48463 h 0.32004 l 0.90678,-1.48463 v 2.55143 h 0.41783 v -3.1115 h -0.5334 l -0.95123,1.56908 -0.95123,-1.56908 h -0.5334 z m 3.951605,0 h 1.67132 v -0.3556 h -1.25349 v -1.05347 h 1.07569 v -0.35115 h -1.07569 v -0.99568 h 1.25349 v -0.3556 h -1.67132 z m 2.502535,0 h 0.41783 v -2.60033 l 1.76022,2.60033 h 0.546735 v -3.1115 h -0.41783 v 2.60032 l -1.76022,-2.60032 H 85.89712 Z m 3.373758,-2.72923 h 1.03124 v 2.72923 h 0.41783 v -2.72923 h 1.03124 v -0.38227 h -2.48031 z"
-       id="text3"
-       style="font-size:4.445px;line-height:0.661464px;font-family:Marianne;-inkscape-font-specification:'Marianne, Normal';letter-spacing:0px;word-spacing:0px;display:inline;stroke:#000000;stroke-width:0.198437"
-       aria-label="GOUVERNEMENT" />
-  </g>
-</svg>

docker/dinum-frontend/dinum-styles.css

@@ -1,70 +0,0 @@
-:root {
-    --fonts-sans: 'Marianne', ui-sans-serif, system-ui, sans-serif;
-}
-
-.Header-beforeLogo {
-    display: block;
-}
-
-.Header-beforeLogo::before {
-    content: '';
-    display: block;
-    background-image: url(/assets/marianne.svg);
-    background-position: 0 -0.046875rem;
-    background-size: 2.0625rem 0.84375rem;
-    height: 0.75rem;
-    margin-bottom: 0.1rem;
-    width: 2.0625rem;
-}
-
-.Header-beforeLogo::after {
-    content: '';
-    display: block;
-    background-image: url(/assets/gouvernement.svg), url(/assets/devise.svg);
-    background-repeat: no-repeat, no-repeat;
-    background-size: 108.8px 10px, 40px 29px;
-    background-position: 0 3px, 0 18.9px;
-    width: 108.8px;
-    height: 48px;
-    margin-top: 0.25rem;
-}
-
-@font-face {
-    font-family: 'Marianne';
-    src: url('/assets/fonts/Marianne-Regular-subset.woff2') format('woff2');
-    font-weight: 400;
-    font-style: normal;
-    font-display: swap;
-}
-
-@font-face {
-    font-family: 'Marianne';
-    src: url('/assets/fonts/Marianne-Regular_Italic-subset.woff2') format('woff2');
-    font-weight: 400;
-    font-style: italic;
-    font-display: swap;
-}
-
-@font-face {
-    font-family: 'Marianne';
-    src: url('/assets/fonts/Marianne-Medium-subset.woff2') format('woff2');
-    font-weight: 500;
-    font-style: normal;
-    font-display: swap;
-}
-
-@font-face {
-    font-family: 'Marianne';
-    src: url('/assets/fonts/Marianne-Bold-subset.woff2') format('woff2');
-    font-weight: 700;
-    font-style: normal;
-    font-display: swap;
-}
-
-@font-face {
-    font-family: 'Marianne';
-    src: url('/assets/fonts/Marianne-ExtraBold-subset.woff2') format('woff2');
-    font-weight: 800;
-    font-style: normal;
-    font-display: swap;
-}

docker/dinum-frontend/logo.svg

@@ -1,6 +0,0 @@
-<svg width="448" height="172" viewBox="0 0 448 172" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M5.61135 65.6951C5 68.832 5 72.6949 5 79.1656V94.7307C5 102.759 5 106.773 6.16756 110.366C7.20062 113.546 8.89041 116.472 11.1274 118.957C13.6555 121.765 17.1318 123.772 24.0842 127.786L37.564 135.568C43.7169 139.121 47.1472 141.101 50.4165 142.054V94.0288C50.4165 91.6281 49.1052 89.4192 46.9976 88.2696L5.61135 65.6951Z" fill="#C9191E"/>
-<path d="M118.313 72.7489V97.7898C118.313 101.252 119.818 104.544 122.436 106.809L140.459 122.406C141.513 123.298 142.608 124.028 143.744 124.596C144.92 125.123 146.056 125.387 147.151 125.387C149.503 125.387 151.389 124.616 152.809 123.075C154.269 121.493 154.999 119.445 154.999 116.93V53.6577C154.999 51.1431 154.269 49.1151 152.809 47.5738C151.389 45.992 149.503 45.2011 147.151 45.2011C146.056 45.2011 144.92 45.4647 143.744 45.992C142.608 46.5193 141.513 47.2494 140.459 48.1822L122.45 63.7172C119.823 65.983 118.313 69.28 118.313 72.7489Z" fill="#000091"/>
-<path d="M11.6345 56.7522C11.1333 56.4788 10.6078 56.2937 10.0757 56.1915C10.4114 55.7628 10.7622 55.3452 11.1276 54.9394C13.6558 52.1315 17.132 50.1245 24.0845 46.1105L37.5643 38.3279C44.5167 34.3139 47.993 32.3069 51.6887 31.5213C54.9587 30.8262 58.3383 30.8262 61.6083 31.5213C65.304 32.3069 68.7803 34.3139 75.7327 38.3279L89.0535 46.0187C89.1066 46.0492 89.1597 46.0798 89.2129 46.1105C96.1653 50.1245 99.6416 52.1316 102.17 54.9394C104.407 57.4238 106.096 60.3506 107.13 63.5301C108.297 67.1235 108.297 71.1375 108.297 79.1656V94.7307C108.297 102.759 108.297 106.773 107.13 110.366C106.096 113.546 104.407 116.473 102.17 118.957C99.6416 121.765 96.1655 123.772 89.2133 127.785C89.1537 127.82 89.0936 127.855 89.0341 127.889L75.7327 135.568C68.7803 139.582 65.304 141.589 61.6083 142.375C61.4564 142.407 61.3043 142.438 61.1519 142.467L61.1519 94.0288C61.1519 87.6997 57.6948 81.8761 52.1386 78.8455L11.6345 56.7522Z" fill="#000091"/>
-<path d="M193.72 45.7333H211.035L234.771 108.456L258.507 45.7333H275.821L245.435 126H224.107L193.72 45.7333ZM289.019 58.1173C283.859 58.1173 279.501 53.76 279.501 48.6C279.501 43.44 283.859 39.0827 289.019 39.0827C294.179 39.0827 298.421 43.44 298.421 48.6C298.421 53.76 294.179 58.1173 289.019 58.1173ZM281.68 126V68.208H296.243V126H281.68ZM303.29 117.629L312.922 108.915C316.477 113.387 320.72 116.597 326.224 116.597C330.925 116.597 333.333 113.845 333.333 110.405C333.333 100.315 305.698 104.099 305.698 83.8027C305.698 73.5973 314.298 65.9147 326.338 65.9147C335.168 65.9147 343.194 70.1573 347.322 75.776L337.69 84.2613C334.709 80.592 330.925 77.6107 326.453 77.6107C321.866 77.6107 319.688 80.1333 319.688 83.1147C319.688 92.976 347.322 89.536 347.322 109.488C347.093 121.643 337.346 128.293 326.453 128.293C316.133 128.293 308.794 124.165 303.29 117.629ZM363.494 58.1173C358.334 58.1173 353.977 53.76 353.977 48.6C353.977 43.44 358.334 39.0827 363.494 39.0827C368.654 39.0827 372.897 43.44 372.897 48.6C372.897 53.76 368.654 58.1173 363.494 58.1173ZM356.155 126V68.208H370.718V126H356.155ZM411.115 65.9147C429.92 65.9147 442.763 79.7893 442.763 97.104C442.763 114.419 429.92 128.293 411.115 128.293C392.309 128.293 379.467 114.419 379.467 97.104C379.467 79.7893 392.309 65.9147 411.115 65.9147ZM411.344 114.533C420.632 114.533 427.627 107.08 427.627 97.104C427.627 87.0133 420.632 79.6747 411.344 79.6747C401.712 79.6747 394.603 87.0133 394.603 97.104C394.603 107.195 401.712 114.533 411.344 114.533Z" fill="#000091"/>
-</svg>

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,117 +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
-    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,370 +0,0 @@
-# Installation on a k8s cluster
-
-This document is a step-by-step guide that describes how to install LaSuite Meet on a k8s cluster without AI features.
-
-## Prerequisites for a kubernetes setup
-
-- 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 kubernetes test cluster, you can install everything on a local kind cluster. In this case, the simplest way is to use our script located in this repo under **bin/start-kind.sh**.
-
-IMPORTANT: The kind method will only deploy meet as a local instance(127.0.0.1) that can only be accessed from the device where it has been deployed. 
-
-To be able to use the script, you will need to install the following components:
-
-- 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)
-- kubectl (https://kubernetes.io/docs/tasks/tools/)
-
-In order to initiate the local kind installation via **start-kind.sh** do the following:
-1) Make sure administrator/root user context is able to execute mkcert, docker, kind etc. commands or the script might fail
-2) Download the script to the device where the above components are installed
-3) Make the script executable
-4) Run the script with proper permissions (administrator/sudo etc.)
-
-The output of the script will resemble the below example:
-
-```
-$ ./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 of components
-
-### What will you use to authenticate your users ?
-
-LaSuite Meet 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 LaSuite Meet) 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. NOTE: Before you proceed, and is using the kind method, make sure you download this repo examples/ directory and its contents to the location where you will be executing the helm command. Helm will look for "examples/<name>values.yaml" from based on the path it is being executed.
-
-```
-$ 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
-```
-
-In your OIDC provider, set LaSuite Meet's redirect URI to `https://.../api/v1.0/callback/` where `...` should be replaced with the domain name LaSuite Meet is hosted on.
-
-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
-
-LaSuite Meet 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
-
-LaSuite Meet 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
-```
-
-## Deployment
-
-Now you are ready to deploy LaSuite Meet 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 LaSuite Meet on https://meet.127.0.0.1.nip.io from the local device. The provisioning user in keycloak is meet/meet.
-
-## All options
-
-These are the environmental options available on meet backend.
-
-| Option                                          | Description                                                                                                                                                  | default                                                                                                                                                       |
-|-------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| DATA_DIR                                        | Data directory location                                                                                                                                      | /data                                                                                                                                                         |
-| DJANGO_ALLOWED_HOSTS                            | Hosts that are allowed                                                                                                                                       | []                                                                                                                                                            |
-| DJANGO_SECRET_KEY                               | Secret key used for Django security                                                                                                                          |                                                                                                                                                               |
-| DJANGO_SILENCED_SYSTEM_CHECKS                   | Silence Django system checks                                                                                                                                 | []                                                                                                                                                            |
-| DJANGO_ALLOW_UNSECURE_USER_LISTING              | Allow unsecure user listing                                                                                                                                  | false                                                                                                                                                         |
-| DB_ENGINE                                       | Database engine used                                                                                                                                         | django.db.backends.postgresql_psycopg2                                                                                                                        |
-| DB_NAME                                         | Name of the database                                                                                                                                         | meet                                                                                                                                                          |
-| DB_USER                                         | User used to connect to database                                                                                                                             | dinum                                                                                                                                                         |
-| DB_PASSWORD                                     | Password used to connect to the database                                                                                                                     | pass                                                                                                                                                          |
-| DB_HOST                                         | Hostname of the database                                                                                                                                     | localhost                                                                                                                                                     |
-| DB_PORT                                         | Port to connect to database                                                                                                                                  | 5432                                                                                                                                                          |
-| STORAGES_STATICFILES_BACKEND                    | Static file serving engine                                                                                                                                   | whitenoise.storage.CompressedManifestStaticFilesStorage                                                                                                       |
-| AWS_S3_ENDPOINT_URL                             | S3 host endpoint                                                                                                                                             |                                                                                                                                                               |
-| AWS_S3_ACCESS_KEY_ID                            | S3 access key                                                                                                                                                |                                                                                                                                                               |
-| AWS_S3_SECRET_ACCESS_KEY                        | S3 secret key                                                                                                                                                |                                                                                                                                                               |
-| AWS_S3_REGION_NAME                              | S3 region                                                                                                                                                    |                                                                                                                                                               |
-| AWS_STORAGE_BUCKET_NAME                         | S3 bucket name                                                                                                                                               | meet-media-storage                                                                                                                                            |
-| DJANGO_LANGUAGE_CODE                            | Default language                                                                                                                                             | en-us                                                                                                                                                         |
-| REDIS_URL                                       | Redis endpoint                                                                                                                                               | redis://redis:6379/1                                                                                                                                          |
-| SESSION_COOKIE_AGE                              | Session cookie expiration in seconds                                                                                                                         | 43200 (12 hours)                                                                                                                                              |
-| REQUEST_ENTRY_THROTTLE_RATES                    | Entry request throttle rates                                                                                                                                 | 150/minute                                                                                                                                                    |
-| CREATION_CALLBACK_THROTTLE_RATES                | Creation callback throttle rates                                                                                                                             | 600/minute                                                                                                                                                    |
-| SPECTACULAR_SETTINGS_ENABLE_DJANGO_DEPLOY_CHECK | Enable Django deploy check                                                                                                                                   | false                                                                                                                                                         |
-| CSRF_TRUSTED_ORIGINS                            | CSRF trusted origins list                                                                                                                                    | []                                                                                                                                                            |
-| FRONTEND_CUSTOM_CSS_URL                         | URL of an additional CSS file to load in the frontend app. If set, a `<link>` tag with this URL as href is added to the `<head>` of the frontend app         |                                                                                                                                                               |
-| FRONTEND_ANALYTICS                              | Analytics information                                                                                                                                        | {}                                                                                                                                                            |
-| FRONTEND_SUPPORT                                | Crisp frontend support configuration, also you can pass help articles, with `help_article_transcript`, `help_article_recording`, `help_article_more_tools`   | {}                                                                                                                                                            |
-| FRONTEND_TRANSCRIPT                             | Frontend transcription configuration, you can pass a beta form, with `form_beta_users`                                                                       | {}                                                                                                                                                            |
-| FRONTEND_MANIFEST_LINK                          | Link to the "Learn more" button on the homepage                                                                                                              | {}                                                                                                                                                            |
-| FRONTEND_SILENCE_LIVEKIT_DEBUG                  | Silence LiveKit debug logs                                                                                                                                   | false                                                                                                                                                         |
-| FRONTEND_IS_SILENT_LOGIN_ENABLED                | Enable silent login feature                                                                                                                                  | true                                                                                                                                                          |
-| FRONTEND_FEEDBACK                               | Frontend feedback configuration                                                                                                                              | {}                                                                                                                                                            |
-| FRONTEND_USE_FRENCH_GOV_FOOTER                  | Show the French government footer in the homepage                                                                                                            | false                                                                                                                                                         |
-| FRONTEND_USE_PROCONNECT_BUTTON                  | Show a "Login with ProConnect" button in the homepage instead of a "Login" button                                                                            | false                                                                                                                                                         |
-| DJANGO_EMAIL_BACKEND                            | Email backend library                                                                                                                                        | django.core.mail.backends.smtp.EmailBackend                                                                                                                   |
-| DJANGO_EMAIL_HOST                               | Host of the email server                                                                                                                                     |                                                                                                                                                               |
-| DJANGO_EMAIL_HOST_USER                          | User to connect to the email server                                                                                                                          |                                                                                                                                                               |
-| DJANGO_EMAIL_HOST_PASSWORD                      | Password to connect to the email server                                                                                                                      |                                                                                                                                                               |
-| DJANGO_EMAIL_PORT                               | Port to connect to the email server                                                                                                                          |                                                                                                                                                               |
-| DJANGO_EMAIL_USE_TLS                            | Enable TLS on email connection                                                                                                                               | false                                                                                                                                                         |
-| DJANGO_EMAIL_USE_SSL                            | Enable SSL on email connection                                                                                                                               | false                                                                                                                                                         |
-| DJANGO_EMAIL_FROM                               | Email from account                                                                                                                                           | from@example.com                                                                                                                                              |
-| EMAIL_BRAND_NAME                                | Email branding name                                                                                                                                          |                                                                                                                                                               |
-| EMAIL_SUPPORT_EMAIL                             | Support email address                                                                                                                                        |                                                                                                                                                               |
-| EMAIL_LOGO_IMG                                  | Email logo image                                                                                                                                             |                                                                                                                                                               |
-| EMAIL_DOMAIN                                    | Email domain                                                                                                                                                 |                                                                                                                                                               |
-| EMAIL_APP_BASE_URL                              | Email app base URL                                                                                                                                           |                                                                                                                                                               |
-| DJANGO_CORS_ALLOW_ALL_ORIGINS                   | Allow all CORS origins                                                                                                                                       | false                                                                                                                                                         |
-| DJANGO_CORS_ALLOWED_ORIGINS                     | Origins to allow (string list)                                                                                                                               | []                                                                                                                                                            |
-| DJANGO_CORS_ALLOWED_ORIGIN_REGEXES              | Origins to allow (regex patterns)                                                                                                                            | []                                                                                                                                                            |
-| SENTRY_DSN                                      | Sentry server DSN                                                                                                                                            |                                                                                                                                                               |
-| DJANGO_CELERY_BROKER_URL                        | Celery broker host                                                                                                                                           | redis://redis:6379/0                                                                                                                                          |
-| DJANGO_CELERY_BROKER_TRANSPORT_OPTIONS          | Celery broker options                                                                                                                                        | {}                                                                                                                                                            |
-| OIDC_CREATE_USER                                | Create OIDC user if not exists                                                                                                                               | true                                                                                                                                                          |
-| OIDC_VERIFY_SSL                                 | Verify SSL for OIDC                                                                                                                                          | true                                                                                                                                                          |
-| OIDC_FALLBACK_TO_EMAIL_FOR_IDENTIFICATION       | Fallback to email for identification                                                                                                                         | false                                                                                                                                                         |
-| OIDC_RP_SIGN_ALGO                               | Token verification algorithm used by OIDC                                                                                                                    | RS256                                                                                                                                                         |
-| OIDC_RP_CLIENT_ID                               | OIDC client ID                                                                                                                                               | meet                                                                                                                                                          |
-| OIDC_RP_CLIENT_SECRET                           | OIDC client secret                                                                                                                                           |                                                                                                                                                               |
-| OIDC_OP_JWKS_ENDPOINT                           | OIDC endpoint for JWKS                                                                                                                                       |                                                                                                                                                               |
-| OIDC_OP_AUTHORIZATION_ENDPOINT                  | OIDC endpoint for authorization                                                                                                                              |                                                                                                                                                               |
-| OIDC_OP_TOKEN_ENDPOINT                          | OIDC endpoint for token                                                                                                                                      |                                                                                                                                                               |
-| OIDC_OP_USER_ENDPOINT                           | OIDC endpoint for user                                                                                                                                       |                                                                                                                                                               |
-| OIDC_OP_USER_ENDPOINT_FORMAT                    | OIDC endpoint format (AUTO, JWT, JSON)                                                                                                                       | AUTO                                                                                                                                                          |
-| OIDC_OP_LOGOUT_ENDPOINT                         | OIDC endpoint for logout                                                                                                                                     |                                                                                                                                                               |
-| OIDC_AUTH_REQUEST_EXTRA_PARAMS                  | Extra parameters for OIDC request                                                                                                                            | {}                                                                                                                                                            |
-| OIDC_RP_SCOPES                                  | OIDC scopes                                                                                                                                                  | openid email                                                                                                                                                  |
-| OIDC_USE_NONCE                                  | Use nonce for OIDC                                                                                                                                           | true                                                                                                                                                          |
-| OIDC_REDIRECT_REQUIRE_HTTPS                     | Require HTTPS for OIDC                                                                                                                                       | false                                                                                                                                                         |
-| OIDC_REDIRECT_ALLOWED_HOSTS                     | Allowed redirect hosts for OIDC                                                                                                                              | []                                                                                                                                                            |
-| OIDC_STORE_ID_TOKEN                             | Store OIDC ID token                                                                                                                                          | true                                                                                                                                                          |
-| OIDC_REDIRECT_FIELD_NAME                        | Redirect field for OIDC                                                                                                                                      | returnTo                                                                                                                                                      |
-| OIDC_USERINFO_FULLNAME_FIELDS                   | Full name claim from OIDC token                                                                                                                              | ["given_name", "usual_name"]                                                                                                                                  |
-| OIDC_USERINFO_SHORTNAME_FIELD                   | Short name claim from OIDC token                                                                                                                             | given_name                                                                                                                                                    |
-| OIDC_USERINFO_ESSENTIAL_CLAIMS                  | Required claims from OIDC token                                                                                                                              | []                                                                                                                                                            |
-| OIDC_USE_PKCE                                   | Enable the use of PKCE (Proof Key for Code Exchange) during the OAuth 2.0 authorization code flow. Recommended for enhanced security.                        | False                                                                                                                                                         |
-| OIDC_PKCE_CODE_CHALLENGE_METHOD                 | Method used to generate the PKCE code challenge. Common values include S256 and plain. Refer to the mozilla-django-oidc documentation for supported options. | S256                                                                                                                                                          |
-| OIDC_PKCE_CODE_VERIFIER_SIZE                    | Length of the random string used as the PKCE code verifier. Must be an integer between 43 and 128, inclusive.                                                | 64                                                                                                                                                            |
-| LOGIN_REDIRECT_URL                              | Login redirect URL                                                                                                                                           |                                                                                                                                                               |
-| LOGIN_REDIRECT_URL_FAILURE                      | Login redirect URL for failure                                                                                                                               |                                                                                                                                                               |
-| LOGOUT_REDIRECT_URL                             | URL to redirect to on logout                                                                                                                                 |                                                                                                                                                               |
-| ALLOW_LOGOUT_GET_METHOD                         | Allow logout through GET method                                                                                                                              | true                                                                                                                                                          |
-| LIVEKIT_API_KEY                                 | LiveKit API key                                                                                                                                              |                                                                                                                                                               |
-| LIVEKIT_API_SECRET                              | LiveKit API secret                                                                                                                                           |                                                                                                                                                               |
-| LIVEKIT_API_URL                                 | LiveKit API URL                                                                                                                                              |                                                                                                                                                               |
-| LIVEKIT_VERIFY_SSL                              | Verify SSL for LiveKit connections                                                                                                                           | true                                                                                                                                                          |
-| LIVEKIT_FORCE_WSS_PROTOCOL                      | Enables WSS protocol conversion for legacy browser compatibility (Firefox <124, Chrome <125, Edge <125) where HTTPS URLs fail in WebSocket() constructor.    | false                                                                                                                                                         |
-| LIVEKIT_ENABLE_FIREFOX_PROXY_WORKAROUND         | Firefox-only connection warmup: pre-calls WebSocket endpoint (expecting 401) to initialize cache, resolving proxy/network connectivity issues.               | false                                                                                                                                                         |
-| RESOURCE_DEFAULT_ACCESS_LEVEL                   | Default resource access level for rooms                                                                                                                      | public                                                                                                                                                        |
-| ALLOW_UNREGISTERED_ROOMS                        | Allow usage of unregistered rooms                                                                                                                            | true                                                                                                                                                          |
-| RECORDING_ENABLE                                | Record meeting option                                                                                                                                        | false                                                                                                                                                         |
-| RECORDING_OUTPUT_FOLDER                         | Folder to store meetings                                                                                                                                     | recordings                                                                                                                                                    |
-| RECORDING_WORKER_CLASSES                        | Worker classes for recording                                                                                                                                 | {"screen_recording": "core.recording.worker.services.VideoCompositeEgressService","transcript": "core.recording.worker.services.AudioCompositeEgressService"} |
-| RECORDING_EVENT_PARSER_CLASS                    | Storage event engine for recording                                                                                                                           | core.recording.event.parsers.MinioParser                                                                                                                      |
-| RECORDING_ENABLE_STORAGE_EVENT_AUTH             | Enable storage event authorization                                                                                                                           | true                                                                                                                                                          |
-| RECORDING_STORAGE_EVENT_ENABLE                  | Enable recording storage events                                                                                                                              | false                                                                                                                                                         |
-| RECORDING_STORAGE_EVENT_TOKEN                   | Recording storage event token                                                                                                                                |                                                                                                                                                               |
-| RECORDING_EXPIRATION_DAYS                       | Recording expiration in days                                                                                                                                 |                                                                                                                                                               |
-| RECORDING_MAX_DURATION                          | Maximum recording duration in milliseconds. Must match LiveKit Egress configuration exactly.                                                                 |                                                                                                                                                               |
-| SCREEN_RECORDING_BASE_URL                       | Screen recording base URL                                                                                                                                    |                                                                                                                                                               |
-| SUMMARY_SERVICE_ENDPOINT                        | Summary service endpoint                                                                                                                                     |                                                                                                                                                               |
-| SUMMARY_SERVICE_API_TOKEN                       | API token for summary service                                                                                                                                |                                                                                                                                                               |
-| SIGNUP_NEW_USER_TO_MARKETING_EMAIL              | Signup users to marketing emails                                                                                                                             | false                                                                                                                                                         |
-| MARKETING_SERVICE_CLASS                         | Marketing service class                                                                                                                                      | core.services.marketing.BrevoMarketingService                                                                                                                 |
-| BREVO_API_KEY                                   | Brevo API key for marketing emails                                                                                                                           |                                                                                                                                                               |
-| BREVO_API_CONTACT_LIST_IDS                      | Brevo API contact list IDs                                                                                                                                   | []                                                                                                                                                            |
-| DJANGO_BREVO_API_CONTACT_ATTRIBUTES             | Brevo contact attributes                                                                                                                                     | {"VISIO_USER": true}                                                                                                                                          |
-| BREVO_API_TIMEOUT                               | Brevo timeout in seconds                                                                                                                                     | 1                                                                                                                                                             |
-| LOBBY_KEY_PREFIX                                | Lobby key prefix                                                                                                                                             | room_lobby                                                                                                                                                    |
-| LOBBY_WAITING_TIMEOUT                           | Lobby waiting timeout in seconds                                                                                                                             | 3                                                                                                                                                             |
-| LOBBY_DENIED_TIMEOUT                            | Lobby deny timeout in seconds                                                                                                                                | 5                                                                                                                                                             |
-| LOBBY_ACCEPTED_TIMEOUT                          | Lobby accept timeout in seconds                                                                                                                              | 21600 (6 hours)                                                                                                                                               |
-| LOBBY_NOTIFICATION_TYPE                         | Lobby notification types                                                                                                                                     | participantWaiting                                                                                                                                            |
-| LOBBY_COOKIE_NAME                               | Lobby cookie name                                                                                                                                            | lobbyParticipantId                                                                                                                                            |
-| ROOM_CREATION_CALLBACK_CACHE_TIMEOUT            | Room creation callback cache timeout                                                                                                                         | 600 (10 minutes)                                                                                                                                              |
-| ROOM_TELEPHONY_ENABLED                          | Enable SIP telephony feature                                                                                                                                 | false                                                                                                                                                         |
-| ROOM_TELEPHONY_PIN_LENGTH                       | Telephony PIN length                                                                                                                                         | 10                                                                                                                                                            |
-| ROOM_TELEPHONY_PIN_MAX_RETRIES                  | Telephony PIN maximum retries                                                                                                                                | 5                                                                                                                                                             |

env.d/development/common.dist

@@ -12,20 +12,12 @@ PYTHONPATH=/app
 # Mail
 DJANGO_EMAIL_HOST="mailcatcher"
 DJANGO_EMAIL_PORT=1025
-DJANGO_EMAIL_BRAND_NAME=La Suite Numérique
-DJANGO_EMAIL_SUPPORT_EMAIL=test@yopmail.com
-DJANGO_EMAIL_LOGO_IMG=http://localhost:3000/assets/logo-suite-numerique.png
-DJANGO_EMAIL_DOMAIN=localhost:3000
-DJANGO_EMAIL_APP_BASE_URL=http://localhost:3000
 
 # Backend url
 MEET_BASE_URL="http://localhost:8072"
 
 # Media
 STORAGES_STATICFILES_BACKEND=django.contrib.staticfiles.storage.StaticFilesStorage
-AWS_S3_ENDPOINT_URL=http://minio:9000
-AWS_S3_ACCESS_KEY_ID=meet
-AWS_S3_SECRET_ACCESS_KEY=password
 
 # OIDC
 OIDC_OP_JWKS_ENDPOINT=http://nginx:8083/realms/meet/protocol/openid-connect/certs
@@ -42,21 +34,12 @@ LOGIN_REDIRECT_URL=http://localhost:3000
 LOGIN_REDIRECT_URL_FAILURE=http://localhost:3000
 LOGOUT_REDIRECT_URL=http://localhost:3000
 
-OIDC_REDIRECT_ALLOWED_HOSTS=localhost:8083,localhost:3000
+OIDC_REDIRECT_ALLOWED_HOSTS=["http://localhost:8083", "http://localhost:3000"]
 OIDC_AUTH_REQUEST_EXTRA_PARAMS={"acr_values": "eidas1"}
 
 # Livekit Token settings
 LIVEKIT_API_SECRET=secret
 LIVEKIT_API_KEY=devkey
-LIVEKIT_API_URL=http://127.0.0.1.nip.io:7880
-LIVEKIT_VERIFY_SSL=False
+LIVEKIT_API_URL=http://localhost:7880
 ALLOW_UNREGISTERED_ROOMS=False
-
-# Recording
-SCREEN_RECORDING_BASE_URL=http://localhost:3000/recordings
-
-# Telephony
-ROOM_TELEPHONY_ENABLED=True
-
-FRONTEND_USE_FRENCH_GOV_FOOTER=False
-FRONTEND_USE_PROCONNECT_BUTTON=False
+WORKER_SECRET=DevPurposeOnly

renovate.json

@@ -7,15 +7,13 @@
       "enabled": false,
       "groupName": "ignored python dependencies",
       "matchManagers": ["pep621"],
-      "matchPackageNames": ["redis"]
+      "matchPackageNames": []
     },
     {
       "enabled": false,
       "groupName": "ignored js dependencies",
       "matchManagers": ["npm"],
-      "matchPackageNames": [
-        "eslint", "react", "react-dom", "@types/react-dom", "@types/react", "react-i18next"
-      ]
+      "matchPackageNames": []
     }
   ]
 }

src/backend/.pylintrc

@@ -447,10 +447,10 @@ max-bool-expr=5
 max-branches=12
 
 # Maximum number of locals for function / method body
-max-locals=20
+max-locals=15
 
 # Maximum number of parents for a class (see R0901).
-max-parents=10
+max-parents=7
 
 # Maximum number of public methods for a class (see R0904).
 max-public-methods=20

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):
@@ -99,7 +70,6 @@ class ResourceAccessInline(admin.TabularInline):
 
     model = models.ResourceAccess
     extra = 0
-    autocomplete_fields = ["user"]
 
 
 @admin.register(models.Room)
@@ -107,46 +77,3 @@ class RoomAdmin(admin.ModelAdmin):
     """Room admin interface declaration."""
 
     inlines = (ResourceAccessInline,)
-    search_fields = ["name", "slug", "=id"]
-    list_display = ["name", "slug", "access_level", "created_at"]
-    list_filter = ["access_level", "created_at"]
-    readonly_fields = ["id", "created_at", "updated_at"]
-
-
-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,)
-    search_fields = ["status", "=id", "worker_id", "room__slug", "=room__id"]
-    list_display = ("id", "status", "room", "get_owner", "created_at", "worker_id")
-    list_filter = ["status", "room", "created_at"]
-    readonly_fields = ["id", "created_at", "updated_at"]
-
-    def get_queryset(self, request):
-        """Optimize queries by prefetching related access and user data to avoid N+1 queries."""
-        return super().get_queryset(request).prefetch_related("accesses__user")
-
-    def get_owner(self, obj):
-        """Return the owner of the recording for display in the admin list."""
-
-        owners = [
-            access
-            for access in obj.accesses.all()
-            if access.role == models.RoleChoices.OWNER
-        ]
-
-        if not owners:
-            return _("No owner")
-
-        if len(owners) > 1:
-            return _("Multiple owners")
-
-        return str(owners[0].user)

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,24 +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(),
-            "expiration_days": settings.RECORDING_EXPIRATION_DAYS,
-            "max_duration": settings.RECORDING_MAX_DURATION,
-        },
-        "telephony": {
-            "enabled": settings.ROOM_TELEPHONY_ENABLED,
-            "phone_number": settings.ROOM_TELEPHONY_PHONE_NUMBER
-            if settings.ROOM_TELEPHONY_ENABLED
-            else None,
-            "default_country": settings.ROOM_TELEPHONY_DEFAULT_COUNTRY,
-        },
-        "livekit": {
-            "url": settings.LIVEKIT_CONFIGURATION["url"],
-            "force_wss_protocol": settings.LIVEKIT_FORCE_WSS_PROTOCOL,
-            "enable_firefox_proxy_workaround": settings.LIVEKIT_ENABLE_FIREFOX_PROXY_WORKAROUND,
-        },
     }
     frontend_configuration.update(settings.FRONTEND_CONFIGURATION)
     return Response(frontend_configuration)

src/backend/core/api/permissions.py

@@ -1,7 +1,5 @@
 """Permission handlers for the Meet core app."""
 
-from django.conf import settings
-
 from rest_framework import permissions
 
 from ..models import RoleChoices
@@ -64,14 +62,18 @@ class RoomPermissions(permissions.BasePermission):
         if request.method == "DELETE":
             return obj.is_owner(user)
 
-        return obj.is_administrator_or_owner(user)
+        return obj.is_administrator(user)
 
 
-class ResourceAccessPermission(IsAuthenticated):
+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.
@@ -80,42 +82,4 @@ class ResourceAccessPermission(IsAuthenticated):
         if request.method == "DELETE" and obj.role == RoleChoices.OWNER:
             return obj.user == user
 
-        return obj.resource.is_administrator_or_owner(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 on room to perform this action."
-
-    def has_object_permission(self, request, view, obj):
-        """Determine if user has privileges on room."""
-        return obj.is_administrator_or_owner(request.user)
-
-
-class IsRecordingEnabled(permissions.BasePermission):
-    """Check if the recording feature is enabled."""
-
-    message = "Access denied, recording is disabled."
-
-    def has_permission(self, request, view):
-        """Determine if access is allowed based on settings."""
-        return settings.RECORDING_ENABLE
-
-
-class IsStorageEventEnabled(permissions.BasePermission):
-    """Check if the storage event feature is enabled."""
-
-    message = "Access denied, storage event is disabled."
-
-    def has_permission(self, request, view):
-        """Determine if access is allowed based on settings."""
-        return settings.RECORDING_STORAGE_EVENT_ENABLE
+        return obj.resource.is_administrator(user)

src/backend/core/api/serializers.py

@@ -1,12 +1,10 @@
 """Client serializers for the Meet core app."""
 
-import uuid
-
+from django.conf import settings
 from django.utils.translation import gettext_lazy as _
 
 from rest_framework import serializers
 from rest_framework.exceptions import PermissionDenied
-from timezone_field.rest_framework import TimeZoneSerializerField
 
 from core import models, utils
 
@@ -14,12 +12,10 @@ from core import models, utils
 class UserSerializer(serializers.ModelSerializer):
     """Serialize users."""
 
-    timezone = TimeZoneSerializerField()
-
     class Meta:
         model = models.User
-        fields = ["id", "email", "full_name", "short_name", "timezone", "language"]
-        read_only_fields = ["id", "email", "full_name", "short_name"]
+        fields = ["id", "email"]
+        read_only_fields = ["id", "email"]
 
 
 class ResourceAccessSerializerMixin:
@@ -39,10 +35,10 @@ class ResourceAccessSerializerMixin:
             # Update
             self.instance
             and (
-                data.get("role") == models.RoleChoices.OWNER
+                data["role"] == models.RoleChoices.OWNER
                 and not self.instance.resource.is_owner(user)
                 or self.instance.role == models.RoleChoices.OWNER
-                and self.instance.user != user
+                and not self.instance.user == user
             )
         ) or (
             # Create
@@ -60,9 +56,7 @@ class ResourceAccessSerializerMixin:
         request = self.context.get("request", None)
         user = getattr(request, "user", None)
 
-        if not (
-            user and user.is_authenticated and resource.is_administrator_or_owner(user)
-        ):
+        if not (user and user.is_authenticated and resource.is_administrator(user)):
             raise PermissionDenied(
                 _("You must be administrator or owner of a room to add accesses to it.")
             )
@@ -93,22 +87,13 @@ 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", "pin_code"]
-        read_only_fields = ["id", "slug", "pin_code"]
+        fields = ["id", "name", "slug", "configuration", "is_public"]
+        read_only_fields = ["id", "slug"]
 
     def to_representation(self, instance):
         """
@@ -122,11 +107,9 @@ class RoomSerializer(serializers.ModelSerializer):
             return output
 
         role = instance.get_role(request.user)
-        is_admin_or_owner = models.RoleChoices.check_administrator_role(
-            role
-        ) or models.RoleChoices.check_owner_role(role)
+        is_admin = models.RoleChoices.check_administrator_role(role)
 
-        if is_admin_or_owner:
+        if role is not None:
             access_serializer = NestedResourceAccessSerializer(
                 instance.accesses.select_related("resource", "user").all(),
                 context=self.context,
@@ -134,133 +117,22 @@ class RoomSerializer(serializers.ModelSerializer):
             )
             output["accesses"] = access_serializer.data
 
-        if not is_admin_or_owner:
+        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["is_administrable"] = is_admin_or_owner
+            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",
-            "mode",
-            "key",
-            "is_expired",
-            "expired_at",
-        ]
-        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("RequestEntrySerializer is validation-only")
-
-    def update(self, instance, validated_data):
-        """Not implemented as this is a validation-only serializer."""
-        raise NotImplementedError("RequestEntrySerializer 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 validate_participant_id(self, value):
-        """Validate that the participant_id is a valid UUID hex string."""
-        try:
-            uuid.UUID(hex=value, version=4)
-        except (ValueError, TypeError) as e:
-            raise serializers.ValidationError("Invalid UUID hex format") from e
-        return value
-
-    def create(self, validated_data):
-        """Not implemented as this is a validation-only serializer."""
-        raise NotImplementedError("ParticipantEntrySerializer is validation-only")
-
-    def update(self, instance, validated_data):
-        """Not implemented as this is a validation-only serializer."""
-        raise NotImplementedError("ParticipantEntrySerializer is validation-only")
-
-
-class CreationCallbackSerializer(serializers.Serializer):
-    """Validate room creation callback data."""
-
-    callback_id = serializers.CharField(required=True)
-
-    def create(self, validated_data):
-        """Not implemented as this is a validation-only serializer."""
-        raise NotImplementedError("CreationCallbackSerializer is validation-only")
-
-    def update(self, instance, validated_data):
-        """Not implemented as this is a validation-only serializer."""
-        raise NotImplementedError("CreationCallbackSerializer is validation-only")
-
-
-class RoomInviteSerializer(serializers.Serializer):
-    """Validate room invite creation data."""
-
-    emails = serializers.ListField(child=serializers.EmailField(), allow_empty=False)
-
-    def create(self, validated_data):
-        """Not implemented as this is a validation-only serializer."""
-        raise NotImplementedError("RoomInviteSerializer is validation-only")
-
-    def update(self, instance, validated_data):
-        """Not implemented as this is a validation-only serializer."""
-        raise NotImplementedError("RoomInviteSerializer is validation-only")

src/backend/core/api/viewsets.py

@@ -1,8 +1,8 @@
 """API endpoints"""
 
+import smtplib
 import uuid
-from logging import getLogger
-from urllib.parse import urlparse
+import requests
 
 from django.conf import settings
 from django.db.models import Q
@@ -10,54 +10,26 @@ 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 (
-    exceptions as drf_exceptions,
+    decorators,
+    mixins,
+    pagination,
+    viewsets,
+)
+from rest_framework import (
+    permissions as drf_permissions,
 )
 from rest_framework import (
     response as drf_response,
 )
-from rest_framework import (
-    status as drf_status,
-)
 
-from core import enums, models, utils
-from core.recording.enums import FileExtension
-from core.recording.event.authentication import StorageEventAuthentication
-from core.recording.event.exceptions import (
-    InvalidBucketError,
-    InvalidFileTypeError,
-    ParsingEventDataError,
-)
-from core.recording.event.notification import notification_service
-from core.recording.event.parsers import get_parser
-from core.recording.worker.exceptions import (
-    RecordingStartError,
-    RecordingStopError,
-)
-from core.recording.worker.factories import (
-    get_worker_service,
-)
-from core.recording.worker.mediator import (
-    WorkerServiceMediator,
-)
-from core.services.invitation import InvitationService
-from core.services.livekit_events import (
-    LiveKitEventsService,
-    LiveKitWebhookError,
-)
-from core.services.lobby import (
-    LobbyParticipantNotFound,
-    LobbyService,
-)
-from core.services.room_creation import RoomCreation
+from core import models, utils
 
+from ..analytics import analytics
 from . import permissions, serializers
 
 # pylint: disable=too-many-ancestors
 
-logger = getLogger(__name__)
-
 
 class NestedGenericViewSet(viewsets.GenericViewSet):
     """
@@ -158,8 +130,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", ""):
@@ -184,18 +157,6 @@ class UserViewSet(
         )
 
 
-class RequestEntryAnonRateThrottle(throttling.AnonRateThrottle):
-    """Throttle Anonymous user requesting room entry"""
-
-    scope = "request_entry"
-
-
-class CreationCallbackAnonRateThrottle(throttling.AnonRateThrottle):
-    """Throttle Anonymous user requesting room generation callback"""
-
-    scope = "creation_callback"
-
-
 class RoomViewSet(
     mixins.CreateModelMixin,
     mixins.DestroyModelMixin,
@@ -230,6 +191,13 @@ class RoomViewSet(
         """
         try:
             instance = self.get_object()
+
+            analytics.track(
+                user=self.request.user,
+                event="Get Room",
+                properties={"slug": instance.slug},
+            )
+
         except Http404:
             if not settings.ALLOW_UNREGISTERED_ROOMS:
                 raise
@@ -278,282 +246,63 @@ class RoomViewSet(
             role=models.RoleChoices.OWNER,
         )
 
-        if callback_id := self.request.data.get("callback_id"):
-            RoomCreation().persist_callback_state(callback_id, room)
-
-    @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)
+    @decorators.action(
+        methods=["POST"],
+        detail=True,
+        url_path="summary",
+        permission_classes=[drf_permissions.AllowAny],
+    )
+    def summary(self, request, pk=None):  # pylint: disable=unused-argument
+        """Wip"""
 
+        secret = self.request.data.get("secret", None)
+        if secret is None or secret != settings.WORKER_SECRET:
+            return drf_response.Response({"message": "Invalid secret"}, status=403)
+
+        summary = self.request.data.get("summary", None)
+        transcript = self.request.data.get("transcript", None)
+
+        instance = self.get_object()
+        owners = instance.get_owners()
+
+        email = owners[0].email
+
+        url = f"https://dinum-pad-dev.osc-fr1.scalingo.io/summary?email={email}"
+        headers = {
+            "Content-Type": "text/plain"
+        }
+        response = requests.post(url, headers=headers, data=summary, allow_redirects=False)
         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,
-            )
+            instance.email_summary(summary=summary, transcript=transcript, owners=owners, link=response.headers['Location'])
+        except smtplib.SMTPException:
+            return drf_response.Response({"message": "Error"}, status=500)
 
-        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
-            )
-
-    @decorators.action(
-        detail=False,
-        methods=["post"],
-        url_path="creation-callback",
-        permission_classes=[],
-        throttle_classes=[CreationCallbackAnonRateThrottle],
-    )
-    def creation_callback(self, request):
-        """Retrieve cached room data via an unauthenticated request with a unique ID.
-
-        Designed for interoperability across iframes, popups, and other contexts,
-        even on the same domain, bypassing browser security restrictions on direct communication.
-        """
-
-        serializer = serializers.CreationCallbackSerializer(data=request.data)
-        serializer.is_valid(raise_exception=True)
-
-        room = RoomCreation().get_callback_state(
-            callback_id=serializer.validated_data.get("callback_id")
-        )
-
-        return drf_response.Response(
-            {"status": "success", "room": room}, status=drf_status.HTTP_200_OK
-        )
-
-    @decorators.action(
-        detail=True,
-        methods=["post"],
-        url_path="invite",
-        permission_classes=[
-            permissions.HasPrivilegesOnRoom,
-        ],
-    )
-    def invite(self, request, pk=None):  # pylint: disable=unused-argument
-        """Send email invitations to join a room.
-
-        This API endpoint allows a user with appropriate privileges to send email invitations
-        to one or more recipients, inviting them to join the specified room.
-        """
-
-        room = self.get_object()
-
-        serializer = serializers.RoomInviteSerializer(data=request.data)
-        serializer.is_valid(raise_exception=True)
-
-        emails = serializer.validated_data.get("emails")
-        emails = list(set(emails))
-
-        InvitationService().invite_to_room(
-            room=room, sender=request.user, emails=emails
-        )
-
-        return drf_response.Response(
-            {"status": "success", "message": "invitations sent"},
-            status=drf_status.HTTP_200_OK,
-        )
+        return drf_response.Response({"message": "Webhook data received"}, status=200)
 
 
-class ResourceAccessViewSet(
-    mixins.CreateModelMixin,
-    mixins.DestroyModelMixin,
-    mixins.RetrieveModelMixin,
-    mixins.UpdateModelMixin,
-    mixins.ListModelMixin,
-    viewsets.GenericViewSet,
-):
-    """
-    API endpoints to access and perform actions on resource accesses.
-    """
+class ResourceAccessListModelMixin:
+    """List mixin for resource access API."""
 
-    permission_classes = [permissions.ResourceAccessPermission]
-    queryset = models.ResourceAccess.objects.all()
-    serializer_class = serializers.ResourceAccessSerializer
+    def get_permissions(self):
+        """User only needs to be authenticated to list rooms access"""
+        if self.action == "list":
+            permission_classes = [permissions.IsAuthenticated]
+        else:
+            return super().get_permissions()
+
+        return [permission() for permission in permission_classes]
 
     def get_queryset(self):
         """Return the queryset according to the action."""
-
         queryset = super().get_queryset()
-
-        # Restrict access to resources the user either has explicit
-        # permissions for or administrative privileges over.
         if self.action == "list":
             user = self.request.user
             queryset = queryset.filter(
@@ -563,166 +312,22 @@ class ResourceAccessViewSet(
                     models.RoleChoices.OWNER,
                 ],
             ).distinct()
-
         return queryset
 
 
-class RecordingViewSet(
+class ResourceAccessViewSet(
+    ResourceAccessListModelMixin,
+    mixins.CreateModelMixin,
     mixins.DestroyModelMixin,
     mixins.ListModelMixin,
     mixins.RetrieveModelMixin,
+    mixins.UpdateModelMixin,
     viewsets.GenericViewSet,
 ):
     """
-    API endpoints to access and perform actions on recordings.
+    API endpoints to access and perform actions on resource accesses.
     """
 
-    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"],
-        url_path="storage-hook",
-        authentication_classes=[StorageEventAuthentication],
-        permission_classes=[permissions.IsStorageEventEnabled],
-    )
-    def on_storage_event_received(self, request, pk=None):  # pylint: disable=unused-argument
-        """Handle incoming storage hook events for recordings."""
-
-        parser = get_parser()
-
-        try:
-            recording_id = parser.get_recording_id(request.data)
-
-        except ParsingEventDataError as e:
-            raise drf_exceptions.PermissionDenied(f"Invalid request data: {e}") from e
-
-        except InvalidBucketError as e:
-            raise drf_exceptions.PermissionDenied("Invalid bucket specified") from e
-
-        except InvalidFileTypeError as e:
-            return drf_response.Response(
-                {"message": f"Ignore this file type, {e}"},
-            )
-
-        try:
-            recording = models.Recording.objects.get(id=recording_id)
-        except models.Recording.DoesNotExist as e:
-            raise drf_exceptions.NotFound("No recording found for this event.") from e
-
-        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."
-            )
-
-        # 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.save()
-
-        return drf_response.Response(
-            {"message": "Event processed."},
-        )
-
-    def _auth_get_original_url(self, request):
-        """
-        Extracts and parses the original URL from the "HTTP_X_ORIGINAL_URL" header.
-        Raises PermissionDenied if the header is missing.
-        The original url is passed by nginx in the "HTTP_X_ORIGINAL_URL" header.
-        See corresponding ingress configuration in Helm chart and read about the
-        nginx.ingress.kubernetes.io/auth-url annotation to understand how the Nginx ingress
-        is configured to do this.
-        Based on the original url and the logged-in user, we must decide if we authorize Nginx
-        to let this request go through (by returning a 200 code) or if we block it (by returning
-        a 403 error). Note that we return 403 errors without any further details for security
-        reasons.
-        """
-        # Extract the original URL from the request header
-        original_url = request.META.get("HTTP_X_ORIGINAL_URL")
-        if not original_url:
-            logger.debug("Missing HTTP_X_ORIGINAL_URL header in subrequest")
-            raise drf_exceptions.PermissionDenied()
-
-        logger.debug("Original url: '%s'", original_url)
-        return urlparse(original_url)
-
-    def _auth_get_url_params(self, pattern, fragment):
-        """
-        Extracts URL parameters from the given fragment using the specified regex pattern.
-        Raises PermissionDenied if parameters cannot be extracted.
-        """
-
-        match = pattern.search(fragment)
-
-        try:
-            return match.groupdict()
-        except (ValueError, AttributeError) as exc:
-            logger.debug("Failed to extract parameters from subrequest URL: %s", exc)
-            raise drf_exceptions.PermissionDenied() from exc
-
-    @decorators.action(detail=False, methods=["get"], url_path="media-auth")
-    def media_auth(self, request, *args, **kwargs):
-        """
-        This view is used by an Nginx subrequest to control access to a recording's
-        media file.
-        When we let the request go through, we compute authorization headers that will be added to
-        the request going through thanks to the nginx.ingress.kubernetes.io/auth-response-headers
-        annotation. The request will then be proxied to the object storage backend who will
-        respond with the file after checking the signature included in headers.
-        """
-
-        parsed_url = self._auth_get_original_url(request)
-
-        url_params = self._auth_get_url_params(
-            enums.RECORDING_STORAGE_URL_PATTERN, parsed_url.path
-        )
-
-        user = request.user
-        recording_id = url_params["recording_id"]
-
-        extension = url_params["extension"]
-        if extension not in [item.value for item in FileExtension]:
-            raise drf_exceptions.ValidationError({"detail": "Unsupported extension."})
-
-        try:
-            recording = models.Recording.objects.get(id=recording_id)
-        except models.Recording.DoesNotExist as e:
-            raise drf_exceptions.NotFound("No recording found for this event.") from e
-
-        if extension != recording.extension:
-            raise drf_exceptions.NotFound("No recording found with this extension.")
-
-        abilities = recording.get_abilities(user)
-
-        if not abilities["retrieve"]:
-            logger.debug("User '%s' lacks permission for attachment", user.id)
-            raise drf_exceptions.PermissionDenied()
-
-        if not recording.is_saved:
-            logger.debug("Recording '%s' has not been saved", recording)
-            raise drf_exceptions.PermissionDenied()
-
-        request = utils.generate_s3_authorization_headers(recording.key)
-
-        return drf_response.Response("authorized", headers=request.headers, status=200)
+    permission_classes = [permissions.ResourceAccessPermission]
+    queryset = models.ResourceAccess.objects.all()
+    serializer_class = serializers.ResourceAccessSerializer

src/backend/core/apps.py

@@ -0,0 +1,11 @@
+"""Meet Core application"""
+# from django.apps import AppConfig
+# from django.utils.translation import gettext_lazy as _
+
+
+# class CoreConfig(AppConfig):
+#     """Configuration class for the Meet core app."""
+
+#     name = "core"
+#     app_label = "core"
+#     verbose_name = _("meet core application")

src/backend/core/authentication/backends.py

@@ -1,98 +1,103 @@
 """Authentication Backends for the Meet core app."""
 
-import contextlib
-
-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 _
 
-from lasuite.oidc_login.backends import (
-    OIDCAuthenticationBackend as LaSuiteOIDCAuthenticationBackend,
+import requests
+from mozilla_django_oidc.auth import (
+    OIDCAuthenticationBackend as MozillaOIDCAuthenticationBackend,
 )
 
 from core.models import User
-from core.services.marketing import (
-    ContactCreationError,
-    ContactData,
-    get_marketing_service,
-)
+
+from ..analytics import analytics
 
 
-class OIDCAuthenticationBackend(LaSuiteOIDCAuthenticationBackend):
+class OIDCAuthenticationBackend(MozillaOIDCAuthenticationBackend):
     """Custom OpenID Connect (OIDC) Authentication Backend.
 
     This class overrides the default OIDC Authentication Backend to accommodate differences
     in the User and Identity models, and handles signed and/or encrypted UserInfo response.
     """
 
-    def get_extra_claims(self, user_info):
-        """
-        Return extra claims from user_info.
+    def get_userinfo(self, access_token, id_token, payload):
+        """Return user details dictionary.
 
-        Args:
-          user_info (dict): The user information dictionary.
+        Parameters:
+        - access_token (str): The access token.
+        - id_token (str): The id token (unused).
+        - payload (dict): The token payload (unused).
+
+        Note: The id_token and payload parameters are unused in this implementation,
+        but were kept to preserve base method signature.
+
+        Note: It handles signed and/or encrypted UserInfo Response. It is required by
+        Agent Connect, which follows the OIDC standard. It forces us to override the
+        base method, which deal with 'application/json' response.
 
         Returns:
-          dict: A dictionary of extra claims.
-
+        - dict: User details dictionary obtained from the OpenID Connect user endpoint.
         """
-        return {
-            # Get user's full name from OIDC fields defined in settings
-            "full_name": self.compute_full_name(user_info),
-            "short_name": user_info.get(settings.OIDC_USERINFO_SHORTNAME_FIELD),
-        }
 
-    def post_get_or_create_user(self, user, claims, is_new_user):
-        """
-        Post-processing after user creation or retrieval.
+        user_response = requests.get(
+            self.OIDC_OP_USER_ENDPOINT,
+            headers={"Authorization": f"Bearer {access_token}"},
+            verify=self.get_settings("OIDC_VERIFY_SSL", True),
+            timeout=self.get_settings("OIDC_TIMEOUT", None),
+            proxies=self.get_settings("OIDC_PROXY", None),
+        )
+        user_response.raise_for_status()
+        userinfo = self.verify_token(user_response.text)
+        return userinfo
 
-        Args:
-          user (User): The user instance.
-          claims (dict): The claims dictionary.
-          is_new_user (bool): Indicates if the user was newly created.
+    def get_or_create_user(self, access_token, id_token, payload):
+        """Return a User based on userinfo. Get or create a new user if no user matches the Sub.
+
+        Parameters:
+        - access_token (str): The access token.
+        - id_token (str): The ID token.
+        - payload (dict): The user payload.
 
         Returns:
-        - None
+        - User: An existing or newly created User instance.
 
+        Raises:
+        - Exception: Raised when user creation is not allowed and no existing user is found.
         """
-        email = claims["email"]
-        if is_new_user and email and settings.SIGNUP_NEW_USER_TO_MARKETING_EMAIL:
-            self.signup_to_marketing_email(email)
 
-    @staticmethod
-    def signup_to_marketing_email(email):
-        """Pragmatic approach to newsletter signup during authentication flow.
+        user_info = self.get_userinfo(access_token, id_token, payload)
+        sub = user_info.get("sub")
 
-        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
-
-        Note: For a more robust solution, consider using Async task processing (Celery/Django-Q)
-        """
-        with contextlib.suppress(
-            ContactCreationError, ImproperlyConfigured, ImportError
-        ):
-            marketing_service = get_marketing_service()
-            contact_data = ContactData(
-                email=email, attributes={"VISIO_SOURCE": ["SIGNIN"]}
-            )
-            marketing_service.create_contact(
-                contact_data, timeout=settings.BREVO_API_TIMEOUT
+        if sub is None:
+            raise SuspiciousOperation(
+                _("User info contained no recognizable user identification")
             )
 
-    def get_existing_user(self, sub, email):
-        """Fetch existing user by sub or email."""
         try:
-            return User.objects.get(sub=sub)
+            user = 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
+            if self.get_settings("OIDC_CREATE_USER", True):
+                user = self.create_user(user_info)
+            else:
+                user = None
+
+        analytics.identify(user=user)
+        return user
+
+    def create_user(self, claims):
+        """Return a newly created User instance."""
+
+        sub = claims.get("sub")
+
+        if sub is None:
+            raise SuspiciousOperation(
+                _("Claims contained no recognizable user identification")
+            )
+
+        user = User.objects.create(
+            sub=sub,
+            email=claims.get("email"),
+            password="!",  # noqa: S106
+        )
+
+        return user

src/backend/core/authentication/urls.py

@@ -0,0 +1,18 @@
+"""Authentication URLs for the People core app."""
+
+from django.urls import path
+
+from mozilla_django_oidc.urls import urlpatterns as mozzila_oidc_urls
+
+from .views import OIDCLogoutCallbackView, OIDCLogoutView
+
+urlpatterns = [
+    # Override the default 'logout/' path from Mozilla Django OIDC with our custom view.
+    path("logout/", OIDCLogoutView.as_view(), name="oidc_logout_custom"),
+    path(
+        "logout-callback/",
+        OIDCLogoutCallbackView.as_view(),
+        name="oidc_logout_callback",
+    ),
+    *mozzila_oidc_urls,
+]

src/backend/core/authentication/views.py

@@ -0,0 +1,187 @@
+"""Authentication Views for the People core app."""
+
+import copy
+from urllib.parse import urlencode
+
+from django.contrib import auth
+from django.core.exceptions import SuspiciousOperation
+from django.http import HttpResponseRedirect
+from django.urls import reverse
+from django.utils import crypto
+
+from mozilla_django_oidc.utils import (
+    absolutify,
+)
+from mozilla_django_oidc.views import (
+    OIDCAuthenticationCallbackView as MozillaOIDCAuthenticationCallbackView,
+)
+from mozilla_django_oidc.views import (
+    OIDCAuthenticationRequestView as MozillaOIDCAuthenticationRequestView,
+)
+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.
+
+    Adds support for handling logout callbacks from the identity provider (OP)
+    by initiating the logout flow if the user has an active session.
+
+    The Django session is retained during the logout process to persist the 'state' OIDC parameter.
+    This parameter is crucial for maintaining the integrity of the logout flow between this call
+    and the subsequent callback.
+    """
+
+    @staticmethod
+    def persist_state(request, state):
+        """Persist the given 'state' parameter in the session's 'oidc_states' dictionary
+
+        This method is used to store the OIDC state parameter in the session, according to the
+        structure expected by Mozilla Django OIDC's 'add_state_and_verifier_and_nonce_to_session'
+        utility function.
+        """
+
+        if "oidc_states" not in request.session or not isinstance(
+            request.session["oidc_states"], dict
+        ):
+            request.session["oidc_states"] = {}
+
+        request.session["oidc_states"][state] = {}
+        request.session.save()
+
+    def construct_oidc_logout_url(self, request):
+        """Create the redirect URL for interfacing with the OIDC provider.
+
+        Retrieves the necessary parameters from the session and constructs the URL
+        required to initiate logout with the OpenID Connect provider.
+
+        If no ID token is found in the session, the logout flow will not be initiated,
+        and the method will return the default redirect URL.
+
+        The 'state' parameter is generated randomly and persisted in the session to ensure
+        its integrity during the subsequent callback.
+        """
+
+        oidc_logout_endpoint = self.get_settings("OIDC_OP_LOGOUT_ENDPOINT")
+
+        if not oidc_logout_endpoint:
+            return self.redirect_url
+
+        reverse_url = reverse("oidc_logout_callback")
+        id_token = request.session.get("oidc_id_token", None)
+
+        if not id_token:
+            return self.redirect_url
+
+        query = {
+            "id_token_hint": id_token,
+            "state": crypto.get_random_string(self.get_settings("OIDC_STATE_SIZE", 32)),
+            "post_logout_redirect_uri": absolutify(request, reverse_url),
+        }
+
+        self.persist_state(request, query["state"])
+
+        return f"{oidc_logout_endpoint}?{urlencode(query)}"
+
+    def post(self, request):
+        """Handle user logout.
+
+        If the user is not authenticated, redirects to the default logout URL.
+        Otherwise, constructs the OIDC logout URL and redirects the user to start
+        the logout process.
+
+        If the user is redirected to the default logout URL, ensure her Django session
+        is terminated.
+        """
+
+        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)
+
+        # If the user is not redirected to the OIDC provider, ensure logout
+        if logout_url == self.redirect_url:
+            auth.logout(request)
+
+        return HttpResponseRedirect(logout_url)
+
+
+class OIDCLogoutCallbackView(MozillaOIDCOIDCLogoutView):
+    """Custom view for handling the logout callback from the OpenID Connect (OIDC) provider.
+
+    Handles the callback after logout from the identity provider (OP).
+    Verifies the state parameter and performs necessary logout actions.
+
+    The Django session is maintained during the logout process to ensure the integrity
+    of the logout flow initiated in the previous step.
+    """
+
+    http_method_names = ["get"]
+
+    def get(self, request):
+        """Handle the logout callback.
+
+        If the user is not authenticated, redirects to the default logout URL.
+        Otherwise, verifies the state parameter and performs necessary logout actions.
+        """
+
+        if not request.user.is_authenticated:
+            return HttpResponseRedirect(self.redirect_url)
+
+        state = request.GET.get("state")
+
+        if state not in request.session.get("oidc_states", {}):
+            msg = "OIDC callback state not found in session `oidc_states`!"
+            raise SuspiciousOperation(msg)
+
+        del request.session["oidc_states"][state]
+        request.session.save()
+
+        auth.logout(request)
+
+        return HttpResponseRedirect(self.redirect_url)
+
+
+class OIDCAuthenticationCallbackView(MozillaOIDCAuthenticationCallbackView):
+    """Custom callback view for handling the silent loging flow."""
+
+    @property
+    def failure_url(self):
+        """Override the failure URL property to handle silent login flow
+
+        A silent login failure (e.g., no active user session) should not be
+        considered as an authentication failure.
+        """
+        if self.request.session.get("silent", None):
+            del self.request.session["silent"]
+            self.request.session.save()
+            return self.success_url
+        return super().failure_url
+
+
+class OIDCAuthenticationRequestView(MozillaOIDCAuthenticationRequestView):
+    """Custom authentication view for handling the silent loging flow."""
+
+    def get_extra_params(self, request):
+        """Handle 'prompt' extra parameter for the silent login flow
+
+        This extra parameter is necessary to distinguish between a standard
+        authentication flow and the silent login flow.
+        """
+        extra_params = self.get_settings("OIDC_AUTH_REQUEST_EXTRA_PARAMS", None)
+        if extra_params is None:
+            extra_params = {}
+        if request.GET.get("silent") == "true":
+            extra_params = copy.deepcopy(extra_params)
+            extra_params.update({"prompt": "none"})
+            request.session["silent"] = True
+            request.session.save()
+        return extra_params

src/backend/core/enums.py

@@ -2,21 +2,9 @@
 Core application enums declaration
 """
 
-import re
-
 from django.conf import global_settings, settings
 from django.utils.translation import gettext_lazy as _
 
-UUID_REGEX = (
-    r"[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}"
-)
-FILE_EXT_REGEX = r"[a-zA-Z0-9]{1,10}"
-
-# pylint: disable=line-too-long
-RECORDING_STORAGE_URL_PATTERN = re.compile(
-    f"/media/{settings.RECORDING_OUTPUT_FOLDER}/(?P<recording_id>{UUID_REGEX:s}).(?P<extension>{FILE_EXT_REGEX:s})"
-)
-
 # Django sets `LANGUAGES` by default with all supported languages. We can use it for
 # the choice of languages which should not be limited to the few languages active in
 # the app.

src/backend/core/factories.py

@@ -1,3 +1,4 @@
+# ruff: noqa: S311
 """
 Core application factories
 """
@@ -22,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")
 
@@ -33,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):
@@ -45,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."""
@@ -67,53 +65,3 @@ 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):
-    """Create fake recording for testing."""
-
-    class Meta:
-        model = models.Recording
-        skip_postgeneration_save = True
-
-    room = factory.SubFactory(RoomFactory)
-    status = models.RecordingStatusChoices.INITIATED
-    mode = models.RecordingModeChoices.SCREEN_RECORDING
-    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_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/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/migrations/0013_alter_user_language.py

@@ -1,18 +0,0 @@
-# Generated by Django 5.1.8 on 2025-04-22 14:52
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('core', '0012_alter_room_access_level'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='user',
-            name='language',
-            field=models.CharField(choices="(('en-us', 'English'), ('fr-fr', 'French'), ('nl-nl', 'Dutch'))", default='en-us', help_text='The language in which the user wants to see the interface.', max_length=10, verbose_name='language'),
-        ),
-    ]

src/backend/core/migrations/0014_room_pin_code.py

@@ -1,45 +0,0 @@
-# Generated by Django 5.1.9 on 2025-05-13 08:22
-
-import secrets
-from django.db import migrations, models
-
-
-def generate_pin_for_rooms(apps, schema_editor):
-    """Generate unique 10-digit PIN codes for existing rooms.
-    The PIN code is required for SIP telephony features.
-    """
-    Room = apps.get_model('core', 'Room')
-    rooms_without_pin_code = Room.objects.filter(pin_code__isnull=True)
-    existing_pins = set(Room.objects.values_list('pin_code', flat=True))
-
-    length = 10
-
-    def generate_pin_code():
-        while True:
-            pin_code = str(secrets.randbelow(10 ** length)).zfill(length)
-            if pin_code not in existing_pins:
-                return pin_code
-
-    for room in rooms_without_pin_code:
-        room.pin_code = generate_pin_code()
-        room.save()
-
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('core', '0013_alter_user_language'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='room',
-            name='pin_code',
-            field=models.CharField(blank=True, help_text='Unique n-digit code that identifies this room in telephony mode.', max_length=None, null=True, unique=True, verbose_name='Room PIN code'),
-        ),
-        migrations.RunPython(
-            generate_pin_for_rooms,
-            reverse_code=migrations.RunPython.noop
-        ),
-    ]

src/backend/core/models.py

@@ -2,11 +2,8 @@
 Declare and configure the models for the Meet core application
 """
 
-import secrets
 import uuid
-from datetime import datetime, timedelta
 from logging import getLogger
-from typing import List, Optional
 
 from django.conf import settings
 from django.contrib.auth import models as auth_models
@@ -14,13 +11,15 @@ from django.contrib.auth.base_user import AbstractBaseUser
 from django.core import mail, validators
 from django.core.exceptions import PermissionDenied, ValidationError
 from django.db import models
-from django.utils import timezone
+from django.template.loader import render_to_string
+from django.utils.functional import lazy
 from django.utils.text import capfirst, slugify
 from django.utils.translation import gettext_lazy as _
 
-from timezone_field import TimeZoneField
+from django.core.mail import EmailMessage
+from django.core.files.base import ContentFile
 
-from .recording.enums import FileExtension
+from timezone_field import TimeZoneField
 
 logger = getLogger(__name__)
 
@@ -35,7 +34,7 @@ class RoleChoices(models.TextChoices):
     @classmethod
     def check_administrator_role(cls, role):
         """Check if a role is administrator."""
-        return role == cls.ADMIN
+        return role in [cls.ADMIN, cls.OWNER]
 
     @classmethod
     def check_owner_role(cls, role):
@@ -43,55 +42,6 @@ class RoleChoices(models.TextChoices):
         return role == cls.OWNER
 
 
-class RecordingStatusChoices(models.TextChoices):
-    """Enumeration of possible states for a recording operation."""
-
-    INITIATED = "initiated", _("Initiated")
-    ACTIVE = "active", _("Active")
-    STOPPED = "stopped", _("Stopped")
-    SAVED = "saved", _("Saved")
-    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 {
-            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}
-
-
-class RecordingModeChoices(models.TextChoices):
-    """Recording mode choices."""
-
-    SCREEN_RECORDING = "screen_recording", _("SCREEN_RECORDING")
-    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
@@ -154,17 +104,14 @@ 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=settings.LANGUAGES,
+        choices=lazy(lambda: settings.LANGUAGES, tuple)(),
         default=settings.LANGUAGE_CODE,
         verbose_name=_("language"),
         help_text=_("The language in which the user wants to see the interface."),
@@ -201,18 +148,34 @@ class User(AbstractBaseUser, BaseModel, auth_models.PermissionsMixin):
 
     class Meta:
         db_table = "meet_user"
-        ordering = ("-created_at",)
         verbose_name = _("user")
         verbose_name_plural = _("users")
 
     def __str__(self):
         return self.email or self.admin_email or str(self.id)
 
-    def email_user(self, subject, message, from_email=None, **kwargs):
+    def email_user(self, subject, transcript, from_email=None, **kwargs):
         """Email this user."""
         if not self.email:
             raise ValueError("User has no email address.")
-        mail.send_mail(subject, message, from_email, [self.email], **kwargs)
+#         mail.send_mail(subject, message, from_email, [self.email], **kwargs)
+
+        email = EmailMessage(
+            subject,
+            kwargs['html_message'],
+            from_email,
+            [self.email],
+        )
+
+#         email.attach_alternative(kwargs['html_message'], "text/html")
+
+        transcript = transcript or ''
+
+        wip_file = ContentFile(transcript, 'transcript.txt')
+
+        email.content_subtype = "html"
+        email.attach(wip_file.name, wip_file.read(), 'text/plain')
+        email.send()
 
     def get_teams(self):
         """
@@ -221,38 +184,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",
@@ -288,13 +231,13 @@ class Resource(BaseModel):
                 role = RoleChoices.MEMBER
         return role
 
-    def is_administrator_or_owner(self, user):
+    def is_administrator(self, user):
         """
-        Check if a user is administrator or owner of the resource."""
-        role = self.get_role(user)
-        return RoleChoices.check_administrator_role(
-            role
-        ) or RoleChoices.check_owner_role(role)
+        Check if a user is administrator of the resource.
+
+        Users carrying the "owner" role are considered as administrators a fortiori.
+        """
+        return RoleChoices.check_administrator_role(self.get_role(user))
 
     def is_owner(self, user):
         """Check if a user is owner of the resource."""
@@ -316,7 +259,6 @@ class ResourceAccess(BaseModel):
 
     class Meta:
         db_table = "meet_resource_access"
-        ordering = ("-created_at",)
         verbose_name = _("Resource access")
         verbose_name_plural = _("Resource accesses")
         constraints = [
@@ -372,25 +314,13 @@ 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,
         verbose_name=_("Visio room configuration"),
         help_text=_("Values for Visio parameters to configure the room."),
     )
-    pin_code = models.CharField(
-        max_length=None,
-        unique=True,
-        blank=True,
-        null=True,
-        verbose_name=_("Room PIN code"),
-        help_text=_("Unique n-digit code that identifies this room in telephony mode."),
-    )
 
     class Meta:
         db_table = "meet_room"
@@ -401,14 +331,6 @@ class Room(Resource):
     def __str__(self):
         return capfirst(self.name)
 
-    def save(self, *args, **kwargs):
-        """Generate a unique n-digit pin code for new rooms."""
-        if settings.ROOM_TELEPHONY_ENABLED and not self.pk and not self.pin_code:
-            self.pin_code = self.generate_unique_pin_code(
-                length=settings.ROOM_TELEPHONY_PIN_LENGTH
-            )
-        super().save(*args, **kwargs)
-
     def clean_fields(self, exclude=None):
         """
         Automatically generate the slug from the name and make sure it does not look like a UUID.
@@ -423,297 +345,31 @@ class Room(Resource):
             pass
         else:
             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
+    def get_owners(self):
+        """Fetch the user who is the owner of the room."""
+        owner_accesses = self.accesses.filter(role=RoleChoices.OWNER)
+        return [access.user for access in owner_accesses]
 
-    @staticmethod
-    def generate_unique_pin_code(length):
-        """Generate a unique n-digit PIN code"""
+    def email_summary(self, owners, summary, transcript, link):
+        """Wip"""
 
-        if length < 4:
-            raise ValueError(
-                "PIN code length must be at least 4 digits for minimal security"
+        template_vars = {
+            "title": _("A new summary is ready"),
+            "room": self.slug,
+            "summary": summary,
+            "link": link,
+        }
+
+        msg_plain = render_to_string("mail/text/summary.txt", template_vars)
+        msg_html = render_to_string("mail/html/summary.html", template_vars)
+
+        for owner in owners:
+            owner.email_user(
+                subject=_("A new summary is ready"),
+                transcript=transcript,
+                from_email=settings.EMAIL_FROM,
+                html_message=msg_html,
+                fail_silently=False,
             )
-
-        max_value = 10**length
-
-        for _ in range(settings.ROOM_TELEPHONY_PIN_MAX_RETRIES):
-            pin_code = str(secrets.randbelow(max_value)).zfill(length)
-            if not Room.objects.filter(pin_code=pin_code).exists():
-                return pin_code
-
-        # Log a warning as a temporary measure until backend observability is implemented.
-        logger.warning(
-            "Failed to generate unique PIN code of length %s after %s attempts",
-            length,
-            settings.ROOM_TELEPHONY_PIN_MAX_RETRIES,
-        )
-
-        return None
-
-
-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(
-        User,
-        on_delete=models.CASCADE,
-        null=True,
-        blank=True,
-    )
-    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,
-        related_name="recordings",
-        verbose_name=_("Room"),
-    )
-    status = models.CharField(
-        max_length=50,
-        choices=RecordingStatusChoices.choices,
-        default=RecordingStatusChoices.INITIATED,
-    )
-    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."
-        ),
-    )
-    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"
-        ordering = ("-created_at",)
-        verbose_name = _("Recording")
-        verbose_name_plural = _("Recordings")
-        constraints = [
-            models.UniqueConstraint(
-                fields=["room"],
-                condition=models.Q(
-                    status__in=[
-                        RecordingStatusChoices.ACTIVE,
-                        RecordingStatusChoices.INITIATED,
-                    ]
-                ),
-                name="unique_initiated_or_active_recording_per_room",
-            )
-        ]
-
-    def __str__(self):
-        return f"Recording {self.id} ({self.status})"
-
-    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)
-
-        return {
-            "destroy": is_owner_or_admin and is_final_status,
-            "partial_update": False,
-            "retrieve": is_owner_or_admin,
-            "stop": is_owner_or_admin 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,
-        }
-
-    @property
-    def is_saved(self) -> bool:
-        """Check if the recording is in a saved state."""
-        return self.status in {
-            RecordingStatusChoices.NOTIFICATION_SUCCEEDED,
-            RecordingStatusChoices.SAVED,
-        }
-
-    @property
-    def extension(self):
-        """Get recording extension based on its mode."""
-        extensions = {
-            RecordingModeChoices.TRANSCRIPT: FileExtension.OGG.value,
-            RecordingModeChoices.SCREEN_RECORDING: FileExtension.MP4.value,
-        }
-        return extensions.get(self.mode, FileExtension.MP4.value)
-
-    @property
-    def key(self):
-        """Generate the file key based on recording mode."""
-
-        return f"{settings.RECORDING_OUTPUT_FOLDER}/{self.id}.{self.extension}"
-
-    @property
-    def expired_at(self) -> Optional[datetime]:
-        """
-        Calculate the expiration date based on created_at and RECORDING_EXPIRATION_DAYS.
-        Returns None if no expiration is configured.
-
-        Note: This is a naive and imperfect implementation since recordings are actually
-        saved to the bucket after created_at timestamp is set. The actual expiration
-        will be determined by the bucket lifecycle policy which operates on the object's
-        timestamp in the storage system, not this value.
-        """
-
-        if not settings.RECORDING_EXPIRATION_DAYS:
-            return None
-
-        return self.created_at + timedelta(days=settings.RECORDING_EXPIRATION_DAYS)
-
-    @property
-    def is_expired(self) -> bool:
-        """
-        Determine if the recording has expired by comparing expired_at with current UTC time.
-        Returns False if no expiration is configured or if expiration date is in the future.
-        """
-        if not self.expired_at:
-            return False
-
-        return self.expired_at < timezone.now()
-
-
-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)

src/backend/core/recording/enums.py

@@ -1,10 +0,0 @@
-"""Enums related to recordings."""
-
-from enum import Enum
-
-
-class FileExtension(Enum):
-    """Enum for file extensions used in recordings."""
-
-    OGG = "ogg"
-    MP4 = "mp4"

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

@@ -1 +0,0 @@
-"""Meet event parser classes, authentication and exceptions."""

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

@@ -1,94 +0,0 @@
-"""Authentication class for storage event token validation."""
-
-import logging
-import secrets
-
-from django.conf import settings
-from django.utils.translation import gettext_lazy as _
-
-from rest_framework.authentication import BaseAuthentication
-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.
-    """
-
-    AUTH_HEADER = "Authorization"
-    TOKEN_TYPE = "Bearer"  # noqa S105
-
-    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
-
-        auth_header = request.headers.get(self.AUTH_HEADER)
-
-        if not auth_header:
-            logger.warning(
-                "Authentication failed: Missing Authorization header (ip: %s)",
-                request.META.get("REMOTE_ADDR"),
-            )
-            raise AuthenticationFailed("Authorization header is required")
-
-        auth_parts = auth_header.split(" ")
-        if len(auth_parts) != 2 or auth_parts[0] != self.TOKEN_TYPE:
-            logger.warning(
-                "Authentication failed: Invalid authorization header (ip: %s)",
-                request.META.get("REMOTE_ADDR"),
-            )
-            raise AuthenticationFailed("Invalid authorization header.")
-
-        token = auth_parts[1]
-
-        # Use constant-time comparison to prevent timing attacks
-        if not secrets.compare_digest(token.encode(), required_token.encode()):
-            logger.warning(
-                "Authentication failed: Invalid token (ip: %s)",
-                request.META.get("REMOTE_ADDR"),
-            )
-            raise AuthenticationFailed("Invalid token")
-
-        return MachineUser(), token
-
-    def authenticate_header(self, request):
-        """Return the WWW-Authenticate header value."""
-        return f"{self.TOKEN_TYPE} realm='Storage event API'"

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

@@ -1,17 +0,0 @@
-"""Storage parsers specific exceptions."""
-
-
-class ParsingEventDataError(Exception):
-    """Raised when the request data is malformed, incomplete, or missing."""
-
-
-class InvalidBucketError(Exception):
-    """Raised when the bucket name in the request does not match the expected one."""
-
-
-class InvalidFileTypeError(Exception):
-    """Raised when the file type in the request is not supported."""
-
-
-class InvalidFilepathError(Exception):
-    """Raised when the filepath in the request is invalid."""

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

@@ -1,173 +0,0 @@
-"""Service to notify external services when a new recording is ready."""
-
-import logging
-import smtplib
-
-from django.conf import settings
-from django.core.mail import send_mail
-from django.template.loader import render_to_string
-from django.utils.translation import get_language, override
-from django.utils.translation import gettext_lazy as _
-
-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:
-            return self._notify_user_by_email(recording)
-
-        logger.error(
-            "Unknown recording mode %s for recording %s",
-            recording.mode,
-            recording.id,
-        )
-        return False
-
-    @staticmethod
-    def _notify_user_by_email(recording) -> bool:
-        """
-        Send an email notification to recording owners when their recording is ready.
-
-        The email includes a direct link that redirects owners to a dedicated download
-        page in the frontend where they can access their specific recording.
-        """
-
-        owner_accesses = (
-            models.RecordingAccess.objects.select_related("user")
-            .filter(
-                role=models.RoleChoices.OWNER,
-                recording_id=recording.id,
-            )
-            .order_by("created_at")
-        )
-
-        if not owner_accesses:
-            logger.error("No owner found for recording %s", recording.id)
-            return False
-
-        context = {
-            "brandname": settings.EMAIL_BRAND_NAME,
-            "support_email": settings.EMAIL_SUPPORT_EMAIL,
-            "logo_img": settings.EMAIL_LOGO_IMG,
-            "domain": settings.EMAIL_DOMAIN,
-            "room_name": recording.room.name,
-            "recording_expiration_days": settings.RECORDING_EXPIRATION_DAYS,
-            "link": f"{settings.SCREEN_RECORDING_BASE_URL}/{recording.id}",
-        }
-
-        has_failures = False
-
-        # We process emails individually rather than in batch because:
-        # 1. Each email requires personalization (timezone, language)
-        # 2. The number of recipients per recording is typically small (not thousands)
-        for access in owner_accesses:
-            user = access.user
-            language = user.language or get_language()
-            with override(language):
-                personalized_context = {
-                    "recording_date": recording.created_at.astimezone(
-                        user.timezone
-                    ).strftime("%Y-%m-%d"),
-                    "recording_time": recording.created_at.astimezone(
-                        user.timezone
-                    ).strftime("%H:%M"),
-                    **context,
-                }
-                msg_html = render_to_string(
-                    "mail/html/screen_recording.html", personalized_context
-                )
-                msg_plain = render_to_string(
-                    "mail/text/screen_recording.txt", personalized_context
-                )
-                subject = str(_("Your recording is ready"))  # Force translation
-
-                try:
-                    send_mail(
-                        subject.capitalize(),
-                        msg_plain,
-                        settings.EMAIL_FROM,
-                        [user.email],
-                        html_message=msg_html,
-                        fail_silently=False,
-                    )
-                except smtplib.SMTPException as exception:
-                    logger.error("notification could not be sent: %s", exception)
-                    has_failures = True
-
-        return not has_failures
-
-    @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
-
-        payload = {
-            "filename": recording.key,
-            "email": owner_access.user.email,
-            "sub": owner_access.user.sub,
-            "room": recording.room.name,
-            "recording_date": recording.created_at.astimezone(
-                owner_access.user.timezone
-            ).strftime("%Y-%m-%d"),
-            "recording_time": recording.created_at.astimezone(
-                owner_access.user.timezone
-            ).strftime("%H:%M"),
-        }
-
-        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

@@ -1,147 +0,0 @@
-"""Meet storage event parser classes."""
-
-import logging
-import re
-from dataclasses import dataclass
-from functools import lru_cache
-from typing import Any, Dict, Optional, Protocol
-
-from django.conf import settings
-from django.utils.module_loading import import_string
-
-from .exceptions import (
-    InvalidBucketError,
-    InvalidFilepathError,
-    InvalidFileTypeError,
-    ParsingEventDataError,
-)
-
-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
-        bucket_name: When the event occurred
-        metadata: Additional event data
-    """
-
-    filepath: str
-    filetype: str
-    bucket_name: str
-    metadata: Optional[Dict[str, Any]]
-
-    def __post_init__(self):
-        if self.filepath is None:
-            raise TypeError("filepath cannot be None")
-        if self.filetype is None:
-            raise TypeError("filetype cannot be None")
-        if self.bucket_name is None:
-            raise TypeError("bucket_name cannot be None")
-
-
-class EventParser(Protocol):
-    """Interface for parsing storage events."""
-
-    def __init__(self, bucket_name, allowed_filetypes=None):
-        """Initialize parser with bucket name and optional allowed filetypes."""
-
-    def parse(self, data: Dict) -> StorageEvent:
-        """Extract storage event data from raw dictionary input."""
-
-    def validate(self, data: StorageEvent) -> None:
-        """Verify storage event data meets all requirements."""
-
-    def get_recording_id(self, data: Dict) -> str:
-        """Extract recording ID from event dictionary."""
-
-
-@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
-    same singleton behavior with simpler code.
-    """
-
-    event_parser_cls = import_string(settings.RECORDING_EVENT_PARSER_CLASS)
-    return event_parser_cls(bucket_name=settings.AWS_STORAGE_BUCKET_NAME)
-
-
-class MinioParser:
-    """Handle parsing and validation of Minio storage events."""
-
-    def __init__(self, bucket_name: str, allowed_filetypes=None):
-        """Initialize parser with target bucket name and accepted filetypes."""
-
-        if not bucket_name:
-            raise ValueError("Bucket name cannot be None or empty")
-
-        self._bucket_name = bucket_name
-        self._allowed_filetypes = allowed_filetypes or {"audio/ogg", "video/mp4"}
-
-        # pylint: disable=line-too-long
-        self._filepath_regex = re.compile(
-            r"(?P<url_encoded_folder_path>(?:[^%]+%2F)+)?(?P<recording_id>[0-9a-fA-F\-]{36})\.(?P<extension>[a-zA-Z0-9]+)"
-        )
-
-    @staticmethod
-    def parse(data):
-        """Convert raw Minio event dictionary to StorageEvent object."""
-
-        if not data:
-            raise ParsingEventDataError("Received empty data.")
-
-        try:
-            record = data["Records"][0]
-            s3 = record["s3"]
-            bucket_name = s3["bucket"]["name"]
-            file_object = s3["object"]
-            filepath = file_object["key"]
-            filetype = file_object["contentType"]
-        except (KeyError, IndexError) as e:
-            raise ParsingEventDataError(f"Missing or malformed key: {e}.") from e
-        try:
-            return StorageEvent(
-                filepath=filepath,
-                filetype=filetype,
-                bucket_name=bucket_name,
-                metadata=None,
-            )
-        except TypeError as e:
-            raise ParsingEventDataError(f"Missing essential data fields: {e}") from e
-
-    def validate(self, event_data: StorageEvent) -> str:
-        """Verify StorageEvent matches bucket, filetype and filepath requirements."""
-
-        if event_data.bucket_name != self._bucket_name:
-            raise InvalidBucketError(
-                f"Invalid bucket: expected {self._bucket_name}, got {event_data.bucket_name}"
-            )
-
-        if event_data.filetype not in self._allowed_filetypes:
-            raise InvalidFileTypeError(
-                f"Invalid file type, expected {self._allowed_filetypes},"
-                f"got '{event_data.filetype}'"
-            )
-
-        match = self._filepath_regex.match(event_data.filepath)
-        if not match:
-            raise InvalidFilepathError(
-                f"Invalid filepath structure: {event_data.filepath}"
-            )
-
-        recording_id = match.group("recording_id")
-        return recording_id
-
-    def get_recording_id(self, data):
-        """Extract recording ID from Minio event through parsing and validation."""
-
-        event_data = self.parse(data)
-        recording_id = self.validate(event_data)
-
-        return recording_id

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

@@ -1,49 +0,0 @@
-"""Recording-related LiveKit Events Service"""
-
-from logging import getLogger
-
-from core import models, utils
-
-logger = getLogger(__name__)
-
-
-class RecordingEventsError(Exception):
-    """Recording event handling fails."""
-
-
-class RecordingEventsService:
-    """Handles recording-related Livekit webhook events."""
-
-    @staticmethod
-    def handle_limit_reached(recording):
-        """Stop recording and notify participants when limit is reached."""
-
-        recording.status = models.RecordingStatusChoices.STOPPED
-        recording.save()
-
-        notification_mapping = {
-            models.RecordingModeChoices.SCREEN_RECORDING: "screenRecordingLimitReached",
-            models.RecordingModeChoices.TRANSCRIPT: "transcriptionLimitReached",
-        }
-
-        notification_type = notification_mapping.get(recording.mode)
-        if not notification_type:
-            return
-
-        try:
-            utils.notify_participants(
-                room_name=str(recording.room.id),
-                notification_data={"type": notification_type},
-            )
-        except utils.NotificationError as e:
-            logger.exception(
-                "Failed to notify participants about recording limit reached: "
-                "room=%s, recording_id=%s, mode=%s",
-                recording.room.id,
-                recording.id,
-                recording.mode,
-            )
-            raise RecordingEventsError(
-                f"Failed to notify participants in room '{recording.room.id}' about "
-                f"recording limit reached (recording_id={recording.id})"
-            ) from e

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

@@ -1 +0,0 @@
-"""Meet worker services classes and exceptions."""

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

@@ -1,21 +0,0 @@
-"""Recording and worker services specific exceptions."""
-
-
-class WorkerRequestError(Exception):
-    """Raised when there is an issue with the worker request"""
-
-
-class WorkerConnectionError(Exception):
-    """Raised when there is an issue connecting to the worker."""
-
-
-class WorkerResponseError(Exception):
-    """Raised when the worker's response is not as expected."""
-
-
-class RecordingStartError(Exception):
-    """Raised when there is an error starting the recording."""
-
-
-class RecordingStopError(Exception):
-    """Raised when there is an error stopping the recording."""

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

@@ -1,73 +0,0 @@
-"""Factory, configurations and Protocol to create worker services"""
-
-import logging
-from dataclasses import dataclass
-from functools import lru_cache
-from typing import Any, ClassVar, Dict, Optional, Protocol, Type
-
-from django.conf import settings
-from django.utils.module_loading import import_string
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass(frozen=True)
-class WorkerServiceConfig:
-    """Declare Worker Service common configurations"""
-
-    output_folder: str
-    server_configurations: Dict[str, Any]
-    bucket_args: Optional[dict]
-
-    @classmethod
-    @lru_cache
-    def from_settings(cls) -> "WorkerServiceConfig":
-        """Load configuration from Django settings with caching for efficiency."""
-
-        logger.debug("Loading WorkerServiceConfig from settings.")
-        return cls(
-            output_folder=settings.RECORDING_OUTPUT_FOLDER,
-            server_configurations=settings.LIVEKIT_CONFIGURATION,
-            bucket_args={
-                "endpoint": settings.AWS_S3_ENDPOINT_URL,
-                "access_key": settings.AWS_S3_ACCESS_KEY_ID,
-                "secret": settings.AWS_S3_SECRET_ACCESS_KEY,
-                "region": settings.AWS_S3_REGION_NAME,
-                "bucket": settings.AWS_STORAGE_BUCKET_NAME,
-                "force_path_style": True,
-            },
-        )
-
-
-class WorkerService(Protocol):
-    """Define the interface for interacting with a worker service."""
-
-    hrid: ClassVar[str]
-
-    def __init__(self, config: WorkerServiceConfig):
-        """Initialize the service with the given configuration."""
-
-    def start(self, room_id: str, recording_id: str) -> str:
-        """Start a recording for a specified room."""
-
-    def stop(self, worker_id: str) -> str:
-        """Stop recording for a specified worker."""
-
-
-def get_worker_service(mode: str) -> WorkerService:
-    """Instantiate a worker service by its mode."""
-
-    worker_registry: Dict[str, str] = settings.RECORDING_WORKER_CLASSES
-
-    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
-
-    worker_class: Type[WorkerService] = import_string(worker_class_path)
-
-    config = WorkerServiceConfig.from_settings()
-    return worker_class(config=config)

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

@@ -1,98 +0,0 @@
-"""Mediator between the worker service and recording instances in the Django ORM."""
-
-import logging
-
-from core.models import Recording, RecordingStatusChoices
-
-from .exceptions import (
-    RecordingStartError,
-    RecordingStopError,
-    WorkerConnectionError,
-    WorkerRequestError,
-    WorkerResponseError,
-)
-from .factories import WorkerService
-
-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.
-    """
-
-    def __init__(self, worker_service: WorkerService):
-        """Initialize the WorkerServiceMediator with the provided worker service."""
-
-        self._worker_service = worker_service
-
-    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.
-        """
-
-        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:
-            logger.exception(
-                "Failed to start recording for room %s: %s", recording.room.slug, e
-            )
-            recording.status = RecordingStatusChoices.FAILED_TO_START
-            raise RecordingStartError() from e
-        else:
-            recording.worker_id = worker_id
-            recording.status = RecordingStatusChoices.ACTIVE
-        finally:
-            recording.save()
-
-        logger.info(
-            "Worker started for room %s (worker ID: %s)",
-            recording.room,
-            recording.worker_id,
-        )
-
-    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.
-        """
-
-        if recording.status != RecordingStatusChoices.ACTIVE:
-            logger.error("Cannot stop recording in %s status.", recording.status)
-            raise RecordingStopError()
-
-        try:
-            response = self._worker_service.stop(worker_id=recording.worker_id)
-        except (WorkerConnectionError, WorkerResponseError) as e:
-            logger.exception(
-                "Failed to stop recording for room %s: %s", recording.room.slug, e
-            )
-            recording.status = RecordingStatusChoices.FAILED_TO_STOP
-            raise RecordingStopError() from e
-        else:
-            recording.status = RecordingStatusChoices[response]
-        finally:
-            recording.save()
-
-        logger.info("Worker stopped for room %s", recording.room)

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

@@ -1,148 +0,0 @@
-"""Worker services in charge of recording a room."""
-
-# pylint: disable=no-member
-
-from asgiref.sync import async_to_sync
-from livekit import api as livekit_api
-
-from ... import utils
-from ..enums import FileExtension
-from .exceptions import WorkerConnectionError, WorkerResponseError
-from .factories import WorkerServiceConfig
-
-
-class BaseEgressService:
-    """Base egress defining common methods 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:
-        """Construct the file path for a given filename and extension.
-        Unsecure method, doesn't handle paths robustly and securely.
-        """
-        return f"{self._config.output_folder}/{filename}.{extension}"
-
-    @async_to_sync
-    async def _handle_request(self, request, method_name: str):
-        """Handle making a request to the LiveKit API and returns the response."""
-
-        lkapi = utils.create_livekit_client(self._config.server_configurations)
-
-        # ruff: noqa: SLF001
-        # pylint: disable=protected-access
-        method = getattr(lkapi._egress, method_name)
-
-        try:
-            response = await method(request)
-            return response
-        except livekit_api.TwirpError as e:
-            raise WorkerConnectionError(
-                f"LiveKit client connection error, {e.message}."
-            ) from e
-        except Exception as e:
-            raise WorkerConnectionError(
-                f"Unexpected error during LiveKit client connection: {str(e)}"
-            ) from e
-
-        finally:
-            await lkapi.aclose()
-
-    def stop(self, worker_id: str) -> str:
-        """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.
-        """
-
-        request = livekit_api.StopEgressRequest(
-            egress_id=worker_id,
-        )
-
-        response = self._handle_request(request, "stop_egress")
-
-        if not response.status:
-            raise WorkerResponseError(
-                "LiveKit response is missing the recording status."
-            )
-
-        # To avoid exposing EgressStatus values and coupling with LiveKit outside of this class,
-        # the response status is mapped to simpler "ABORTED", "STOPPED" or "FAILED_TO_STOP" strings.
-        if response.status == livekit_api.EgressStatus.EGRESS_ABORTED:
-            return "ABORTED"
-
-        if response.status == livekit_api.EgressStatus.EGRESS_ENDING:
-            return "STOPPED"
-
-        return "FAILED_TO_STOP"
-
-    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).
-        """
-        raise NotImplementedError("Subclass must implement this method.")
-
-
-class VideoCompositeEgressService(BaseEgressService):
-    """Record multiple participant video and audio tracks into a single output '.mp4' file."""
-
-    hrid = "video-recording-composite-livekit-egress"
-
-    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=FileExtension.MP4.value
-        )
-
-        file_output = livekit_api.EncodedFileOutput(
-            file_type=file_type,
-            filepath=filepath,
-            s3=self._s3,
-        )
-
-        request = livekit_api.RoomCompositeEgressRequest(
-            room_name=room_name, file_outputs=[file_output], layout="speaker-light"
-        )
-
-        response = self._handle_request(request, "start_room_composite_egress")
-
-        if not response.egress_id:
-            raise WorkerResponseError("Egress ID not found in the response.")
-
-        return response.egress_id
-
-
-class AudioCompositeEgressService(BaseEgressService):
-    """Record multiple participant audio tracks into a single output '.ogg' file."""
-
-    hrid = "audio-recording-composite-livekit-egress"
-
-    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=FileExtension.OGG.value
-        )
-
-        file_output = livekit_api.EncodedFileOutput(
-            file_type=file_type,
-            filepath=filepath,
-            s3=self._s3,
-        )
-
-        request = livekit_api.RoomCompositeEgressRequest(
-            room_name=room_name, file_outputs=[file_output], audio_only=True
-        )
-
-        response = self._handle_request(request, "start_room_composite_egress")
-
-        if not response.egress_id:
-            raise WorkerResponseError("Egress ID not found in the response.")
-
-        return response.egress_id

src/backend/core/services/invitation.py

@@ -1,59 +0,0 @@
-"""Invitation Service."""
-
-import smtplib
-from logging import getLogger
-
-from django.conf import settings
-from django.core.mail import send_mail
-from django.template.loader import render_to_string
-from django.utils.translation import get_language, override
-from django.utils.translation import gettext_lazy as _
-
-logger = getLogger(__name__)
-
-
-class InvitationError(Exception):
-    """Exception raised when invitation emails cannot be sent."""
-
-    status_code = 500
-
-
-class InvitationService:
-    """Service for invitations to users."""
-
-    @staticmethod
-    def invite_to_room(room, sender, emails):
-        """Send invitation emails to join a room."""
-
-        language = get_language()
-
-        context = {
-            "brandname": settings.EMAIL_BRAND_NAME,
-            "logo_img": settings.EMAIL_LOGO_IMG,
-            "domain": settings.EMAIL_DOMAIN,
-            "room_url": f"{settings.EMAIL_APP_BASE_URL}/{room.slug}",
-            "room_link": f"{settings.EMAIL_DOMAIN}/{room.slug}",
-            "sender_email": sender.email,
-        }
-
-        with override(language):
-            msg_html = render_to_string("mail/html/invitation.html", context)
-            msg_plain = render_to_string("mail/text/invitation.txt", context)
-            subject = str(
-                _(
-                    f"Video call in progress: {sender.email} is waiting for you to connect"
-                )
-            )  # Force translation
-
-            try:
-                send_mail(
-                    subject,
-                    msg_plain,
-                    settings.EMAIL_FROM,
-                    emails,
-                    html_message=msg_html,
-                    fail_silently=False,
-                )
-            except smtplib.SMTPException as e:
-                logger.error("invitation to %s was not sent: %s", emails, e)
-                raise InvitationError("Could not send invitation") from e

src/backend/core/services/livekit_events.py

@@ -1,198 +0,0 @@
-"""LiveKit Events Service"""
-
-# pylint: disable=E1101
-
-import uuid
-from enum import Enum
-from logging import getLogger
-
-from django.conf import settings
-
-from livekit import api
-
-from core import models
-from core.recording.services.recording_events import (
-    RecordingEventsError,
-    RecordingEventsService,
-)
-
-from .lobby import LobbyService
-from .telephony import TelephonyException, TelephonyService
-
-logger = getLogger(__name__)
-
-
-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()
-        self.telephony_service = TelephonyService()
-        self.recording_events = RecordingEventsService()
-
-    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_egress_ended(self, data):
-        """Handle 'egress_ended' event."""
-
-        try:
-            recording = models.Recording.objects.get(
-                worker_id=data.egress_info.egress_id
-            )
-        except models.Recording.DoesNotExist as err:
-            raise ActionFailedError(
-                f"Recording with worker ID {data.egress_info.egress_id} does not exist"
-            ) from err
-
-        if (
-            data.egress_info.status == api.EgressStatus.EGRESS_LIMIT_REACHED
-            and recording.status == models.RecordingStatusChoices.ACTIVE
-        ):
-            try:
-                self.recording_events.handle_limit_reached(recording)
-            except RecordingEventsError as e:
-                raise ActionFailedError(
-                    f"Failed to process limit reached event for recording {recording}"
-                ) from e
-
-    def _handle_room_started(self, data):
-        """Handle 'room_started' event."""
-
-        try:
-            room_id = uuid.UUID(data.room.name)
-        except ValueError as e:
-            logger.warning(
-                "Ignoring room event: room name '%s' is not a valid UUID format.",
-                data.room.name,
-            )
-            raise ActionFailedError("Failed to process room started event") from e
-
-        try:
-            room = models.Room.objects.get(id=room_id)
-        except models.Room.DoesNotExist as err:
-            raise ActionFailedError(f"Room with ID {room_id} does not exist") from err
-
-        if settings.ROOM_TELEPHONY_ENABLED:
-            try:
-                self.telephony_service.create_dispatch_rule(room)
-            except TelephonyException as e:
-                raise ActionFailedError(
-                    f"Failed to create telephony dispatch rule for room {room_id}"
-                ) from e
-
-    def _handle_room_finished(self, data):
-        """Handle 'room_finished' event."""
-
-        try:
-            room_id = uuid.UUID(data.room.name)
-        except ValueError as e:
-            logger.warning(
-                "Ignoring room event: room name '%s' is not a valid UUID format.",
-                data.room.name,
-            )
-            raise ActionFailedError("Failed to process room finished event") from e
-
-        if settings.ROOM_TELEPHONY_ENABLED:
-            try:
-                self.telephony_service.delete_dispatch_rule(room_id)
-            except TelephonyException as e:
-                raise ActionFailedError(
-                    f"Failed to delete telephony dispatch rule for room {room_id}"
-                ) from e
-
-        try:
-            self.lobby_service.clear_room_cache(room_id)
-        except Exception as e:
-            raise ActionFailedError(
-                f"Failed to clear room cache for room {room_id}"
-            ) from e

src/backend/core/services/lobby.py

@@ -1,336 +0,0 @@
-"""Lobby Service"""
-
-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 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."""
-
-
-@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.
-        """
-
-        color = utils.generate_color(participant_id)
-
-        participant = LobbyParticipant(
-            status=LobbyParticipantStatus.WAITING,
-            username=username,
-            id=participant_id,
-            color=color,
-        )
-
-        try:
-            utils.notify_participants(
-                room_name=str(room_id),
-                notification_data={
-                    "type": settings.LOBBY_NOTIFICATION_TYPE,
-                },
-            )
-        except utils.NotificationError:
-            # If room not created yet, there is no participants to notify
-            logger.exception("Failed to notify room participants")
-
-        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)
-
-    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,138 +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
-import urllib3
-
-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,
-            urllib3.exceptions.ReadTimeoutError,
-        ) as err:
-            logger.warning("Failed to create contact in Brevo", exc_info=True)
-            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()