Publish meet-0.0.17.tgz

.dockerignore

@@ -1,36 +0,0 @@
-# Python
-__pycache__
-*.pyc
-**/__pycache__
-**/*.pyc
-venv
-.venv
-
-# System-specific files
-.DS_Store
-**/.DS_Store
-
-# Docker
-docker compose.*
-env.d
-
-# Docs
-docs
-*.md
-*.log
-
-# Development/test cache & configurations
-data
-.cache
-.circleci
-.git
-.vscode
-.iml
-.idea
-db.sqlite3
-.mypy_cache
-.pylint.d
-.pytest_cache
-
-# Frontend
-node_modules

.github/ISSUE_TEMPLATE/Bug_report.md

@@ -1,28 +0,0 @@
----
-name: 🐛 Bug Report
-about: If something is not working as expected 🤔.
-
----
-
-## Bug Report
-
-**Problematic behavior**
-A clear and concise description of the behavior.
-
-**Expected behavior/code**
-A clear and concise description of what you expected to happen (or code).
-
-**Steps to Reproduce**
-1. Do this...
-2. Then this...
-3. And then the bug happens!
-
-**Environment**
-- Meet version:
-- Platform:
-
-**Possible Solution**
-<!--- Only if you have suggestions on a fix for the bug -->
-
-**Additional context/Screenshots**
-Add any other context about the problem here. If applicable, add screenshots to help explain.

.github/ISSUE_TEMPLATE/Feature_request.md

@@ -1,23 +0,0 @@
----
-name: ✨ Feature Request
-about: I have a suggestion (and may want to build it 💪)!
-
----
-
-## Feature Request
-
-**Is your feature request related to a problem or unsupported use case? Please describe.**
-A clear and concise description of what the problem is. For example: I need to do some task and I have an issue...
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen. Add any considered drawbacks.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Discovery, Documentation, Adoption, Migration Strategy**
-If you can, explain how users will be able to use this and possibly write out a version the docs (if applicable).
-Maybe a screenshot or design?
-
-**Do you want to work on it through a Pull Request?**
-<!-- Make sure to coordinate with us before you spend too much time working on an implementation! -->

.github/ISSUE_TEMPLATE/Support_question.md

@@ -1,22 +0,0 @@
----
-name: 🤗 Support Question
-about: If you have a question 💬, or something was not clear from the docs!
-
----
-
-<!-- ^ Click "Preview" for a nicer view! ^
-We primarily use GitHub as an issue tracker. If however you're encountering an issue not covered in the docs, we may be able to help! -->
-
----
-
-Please make sure you have read our [main Readme](https://github.com/numerique-gouv/meet).
-
-Also make sure it was not already answered in [an open or close issue](https://github.com/numerique-gouv/meet/issues).
-
-If your question was not covered, and you feel like it should be, fire away! We'd love to improve our docs! 👌
-
-**Topic**
-What's the general area of your question: for example, docker setup, database schema, search functionality,...
-
-**Question**
-Try to be as specific as possible so we can help you as best we can. Please be patient 🙏

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,11 +0,0 @@
-## Purpose
-
-Description...
-
-
-## Proposal
-
-Description...
-
-- [] item 1...
-- [] item 2...

.github/workflows/crowdin-download.yml

@@ -1,33 +0,0 @@
-name: Download Crowdin translations
-
-on:
-  workflow_dispatch:
-    types: [file-fully-translated]
-
-permissions:
-  contents: write
-  pull-requests: write
-
-jobs:
-  crowdin:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Download Crowdin files
-        uses: crowdin/github-action@v2
-        with:
-          upload_sources: false
-          upload_translations: false
-          download_translations: true
-          localization_branch_name: l10n_crowdin_translations
-          create_pull_request: true
-          pull_request_title: "New Crowdin translations"
-          pull_request_body: "New Crowdin pull request with translations"
-          pull_request_base_branch_name: "main"
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          CROWDIN_PROJECT_ID: ${{ secrets.CROWDIN_PROJECT_ID }}
-          CROWDIN_PERSONAL_TOKEN: ${{ secrets.CROWDIN_PERSONAL_TOKEN }}
-          CROWDIN_BASE_PATH: ${{ github.workspace }}

.github/workflows/deploy.yml

@@ -1,52 +0,0 @@
-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,200 +0,0 @@
-name: Docker Hub Workflow
-run-name: Docker Hub Workflow
-
-on:
-  workflow_dispatch:
-  push:
-    branches:
-      - 'main'
-    tags:
-      - 'v*'
-  pull_request:
-    branches:
-      - 'main'
-
-env:
-  DOCKER_USER: 1001:127
-
-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
-        uses: docker/metadata-action@v5
-        with:
-          images: lasuite/meet-backend
-      -
-        name: Login to DockerHub
-        if: github.event_name != 'pull_request'
-        run: echo "$DOCKER_HUB_PASSWORD" | docker login -u "$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 }}'
-      -
-        name: Build and push
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          target: backend-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-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
-        uses: docker/metadata-action@v5
-        with:
-          images: lasuite/meet-frontend
-      -
-        name: Login to DockerHub
-        if: github.event_name != 'pull_request'
-        run: echo "$DOCKER_HUB_PASSWORD" | docker login -u "$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 }}'
-      -
-        name: Build and push
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          file: ./src/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:
-      -
-        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
-        uses: docker/metadata-action@v5
-        with:
-          images: lasuite/meet-summary
-      -
-        name: Login to DockerHub
-        if: github.event_name != 'pull_request'
-        run: echo "$DOCKER_HUB_PASSWORD" | docker login -u "$DOCKER_HUB_USER" --password-stdin
-      -
-        name: Build and push
-        uses: docker/build-push-action@v6
-        with:
-          context: ./src/summary
-          file: ./src/summary/Dockerfile
-          target: production
-          build-args: DOCKER_USER=${{ env.DOCKER_USER }}:-1000
-          push: ${{ github.event_name != 'pull_request' }}
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-
-
-  notify-argocd:
-    needs:
-      - build-and-push-frontend
-      - build-and-push-backend
-      - build-and-push-summary
-    runs-on: ubuntu-latest
-    if: |
-      github.event_name != 'pull_request'
-    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

.github/workflows/helmfile-linter.yml

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

.github/workflows/meet.yml

@@ -1,243 +0,0 @@
-name: meet Workflow
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    branches:
-      - "*"
-
-jobs:
-  lint-git:
-    runs-on: ubuntu-latest
-    if: github.event_name == 'pull_request' # Makes sense only for pull requests
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: show
-        run: git log
-      - name: Enforce absence of print statements in code
-        run: |
-          ! git diff origin/${{ github.event.pull_request.base.ref }}..HEAD -- . ':(exclude)**/meet.yml' | grep "print("
-      - name: Check absence of fixup commits
-        run: |
-          ! git log | grep 'fixup!'
-      - name: Install gitlint
-        run: pip install --user requests gitlint
-      - name: Lint commit messages added to main
-        run: ~/.local/bin/gitlint --commits origin/${{ github.event.pull_request.base.ref }}..HEAD
-
-  build-mails:
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: src/mail
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Install Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: "18"
-
-      - name: Restore the mail templates
-        uses: actions/cache@v4
-        id: mail-templates
-        with:
-          path: "src/backend/core/templates/mail"
-          key: mail-templates-${{ hashFiles('src/mail/mjml') }}
-
-      - name: Install yarn
-        if: steps.mail-templates.outputs.cache-hit != 'true'
-        run: npm install -g yarn
-
-      - name: Install node dependencies
-        if: steps.mail-templates.outputs.cache-hit != 'true'
-        run: yarn install --frozen-lockfile
-
-      - name: Build mails
-        if: steps.mail-templates.outputs.cache-hit != 'true'
-        run: yarn build
-
-      - name: Cache mail templates
-        if: steps.mail-templates.outputs.cache-hit != 'true'
-        uses: actions/cache@v4
-        with:
-          path: "src/backend/core/templates/mail"
-          key: mail-templates-${{ hashFiles('src/mail/mjml') }}
-
-  lint-back:
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: src/backend
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-      - name: Install Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.10"
-      - name: Install development dependencies
-        run: pip install --user .[dev]
-      - name: Check code formatting with ruff
-        run: ~/.local/bin/ruff format . --diff
-      - name: Lint code with ruff
-        run: ~/.local/bin/ruff check .
-      - name: Lint code with pylint
-        run: ~/.local/bin/pylint meet demo core
-
-  test-back:
-    runs-on: ubuntu-latest
-    needs: build-mails
-
-    defaults:
-      run:
-        working-directory: src/backend
-
-    services:
-      postgres:
-        image: postgres:16
-        env:
-          POSTGRES_DB: meet
-          POSTGRES_USER: dinum
-          POSTGRES_PASSWORD: pass
-        ports:
-          - 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
-
-    env:
-      DJANGO_CONFIGURATION: Test
-      DJANGO_SETTINGS_MODULE: meet.settings
-      DJANGO_SECRET_KEY: ThisIsAnExampleKeyForTestPurposeOnly
-      OIDC_OP_JWKS_ENDPOINT: /endpoint-for-test-purpose-only
-      DB_HOST: localhost
-      DB_NAME: meet
-      DB_USER: dinum
-      DB_PASSWORD: pass
-      DB_PORT: 5432
-      STORAGES_STATICFILES_BACKEND: django.contrib.staticfiles.storage.StaticFilesStorage
-      LIVEKIT_API_SECRET: secret
-      LIVEKIT_API_KEY: devkey
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Create writable /data
-        run: |
-          sudo mkdir -p /data/media && \
-          sudo mkdir -p /data/static
-
-      - name: Restore the mail templates
-        uses: actions/cache@v4
-        id: mail-templates
-        with:
-          path: "src/backend/core/templates/mail"
-          key: mail-templates-${{ hashFiles('src/mail/mjml') }}
-
-      - name: Install Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.10"
-
-      - name: Install development dependencies
-        run: pip install --user .[dev]
-
-      - name: Install gettext (required to compile messages)
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y gettext
-
-      - name: Generate a MO file from strings extracted from the project
-        run: python manage.py compilemessages
-
-      - name: Run tests
-        run: ~/.local/bin/pytest -n 2
-
-  lint-front:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Install dependencies
-        run: cd src/frontend/ && npm ci
-
-      - name: Check linting
-        run: cd src/frontend/ && npm run lint
-
-      - name: Check format
-        run: cd src/frontend/ && npm run check
-
-  i18n-crowdin:
-    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: "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: cd src/frontend/ && npm ci
-
-      - name: Extract the frontend translation
-        run: make frontend-i18n-extract
-
-      - 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 }}

.gitignore

@@ -1,81 +0,0 @@
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-pip-wheel-metadata/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-.DS_Store
-.next/
-
-# Translations	# Translations
-*.pot
-
-# Environments
-.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-env.d/development/*
-!env.d/development/*.dist
-env.d/terraform
-
-# npm
-node_modules
-
-# Mails
-src/backend/core/templates/mail/
-
-# Swagger
-**/swagger.json
-
-# Logs
-*.log
-
-# Terraform
-.terraform
-*.tfstate
-*.tfstate.backup
-
-# Test & lint
-.coverage
-.pylint.d
-.pytest_cache
-db.sqlite3
-.mypy_cache
-
-# Site media
-/data/
-
-# IDEs
-.idea/
-.vscode/
-*.iml
-.devcontainer
-
-# Egress output
-docker/livekit/out

.gitlint

@@ -1,83 +0,0 @@
-# All these sections are optional, edit this file as you like.
-[general]
-# Ignore certain rules, you can reference them by their id or by their full name
-# ignore=title-trailing-punctuation, T3
-
-# verbosity should be a value between 1 and 3, the commandline -v flags take precedence over this
-# verbosity = 2
-
-# By default gitlint will ignore merge commits. Set to 'false' to disable.
-# ignore-merge-commits=true
-
-# By default gitlint will ignore fixup commits. Set to 'false' to disable.
-# ignore-fixup-commits=true
-
-# By default gitlint will ignore squash commits. Set to 'false' to disable.
-# ignore-squash-commits=true
-
-# Enable debug mode (prints more output). Disabled by default.
-# debug=true
-
-# Set the extra-path where gitlint will search for user defined rules
-# See http://jorisroovers.github.io/gitlint/user_defined_rules for details
-extra-path=gitlint/
-
-# [title-max-length]
-# line-length=80
-
-[title-must-not-contain-word]
-# Comma-separated list of words that should not occur in the title. Matching is case
-# insensitive. It's fine if the keyword occurs as part of a larger word (so "WIPING"
-# will not cause a violation, but "WIP: my title" will.
-words=wip
-
-#[title-match-regex]
-# python like regex (https://docs.python.org/2/library/re.html) that the
-# commit-msg title must be matched to.
-# Note that the regex can contradict with other rules if not used correctly
-# (e.g. title-must-not-contain-word).
-#regex=
-
-# [B1]
-# B1 = body-max-line-length
-# line-length=120
-# [body-min-length]
-# min-length=5
-
-# [body-is-missing]
-# Whether to ignore this rule on merge commits (which typically only have a title)
-# default = True
-# ignore-merge-commits=false
-
-# [body-changed-file-mention]
-# List of files that need to be explicitly mentioned in the body when they are changed
-# This is useful for when developers often erroneously edit certain files or git submodules.
-# By specifying this rule, developers can only change the file when they explicitly reference
-# it in the commit message.
-# files=gitlint/rules.py,README.md
-
-# [author-valid-email]
-# python like regex (https://docs.python.org/2/library/re.html) that the
-# commit author email address should be matched to
-# For example, use the following regex if you only want to allow email addresses from foo.com
-# regex=[^@]+@foo.com
-
-[ignore-by-title:bots]
-# Allow empty body & wrong title pattern only when bots (pyup/greenkeeper)
-# upgrade dependencies
-regex=^(⬆️.*|Update (.*) from (.*) to (.*)|(chore|fix)\(package\): update .*)$
-ignore=B6,UC1
-
-[ignore-by-title:releases]
-# Allow empty body for release commits
-regex=^🔖.*$
-ignore=B6
-
-# [ignore-by-body]
-# Ignore certain rules for commits of which the body has a line that matches a regex
-# E.g. Match bodies that have a line that that contain "release"
-# regex=(.*)release(.*)
-#
-# Ignore certain rules, you can reference them by their id or by their full name
-# Use 'all' to ignore all rules
-# ignore=T1,body-min-length

.gitmodules

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

.sops.yaml

@@ -1,12 +0,0 @@
-creation_rules:
-  - key_groups:
-    - age:
-      - age15fyxdwmg5mvldtqqus87xspuws2u0cpvwheehrtvkexj4tnsqqysw6re2x #jacques
-      - age16hnlml8yv4ynwy0seer57g8qww075crd0g7nsundz3pj4wk7m3vqftszg7 #github-repo
-      - age1plkp8td6zzfcavjusmsfrlk54t9vn8jjxm8zaz7cmnr7kzl2nfnsd54hwg #anthony
-      - age12g6f5fse25tgrwweleh4jls3qs52hey2edh759smulwmk5lnzadslu2cp3 #antoine
-      - age1tl80n23wq6zxegupwn70ew0yp225ua5v4dk800x7g2w6pvlxz46qk592pa #marie
-      - age1qy04neuzwpasmvljqrcvhwnf0kz5cpyteze38c8avp0czewskasszv9pyw #argocd
-      - age18fgn6j2vwwswqcpv9xpcehq8mrf9zs2sglwkamp3tzwx8d9jq9jsrskrk9 #manuuu
-      - age1hm2hsfgjezpsc3k0y5w5feq9t8vl3seq04qjhgt6ztd6403wfvpsgxu09m # github-repo
-      - age1hnhuzj96ktkhpyygvmz0x9h8mfvssz7ss6emmukags644mdhf4msajk93r # Samuel Paccoud

CHANGELOG.md

@@ -1,9 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0),
-and this project adheres to
-[Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [Unreleased]

Dockerfile

@@ -1,141 +0,0 @@
-# Django Meet
-
-# ---- base image to inherit from ----
-FROM python:3.12.6-alpine3.20 AS base
-
-# Upgrade pip to its latest release to speed up dependencies installation
-RUN python -m pip install --upgrade pip setuptools
-
-# Upgrade system packages to install security updates
-RUN apk update && \
-  apk upgrade
-
-# ---- Back-end builder image ----
-FROM base AS back-builder
-
-WORKDIR /builder
-
-# Copy required python dependencies
-COPY ./src/backend /builder
-
-RUN mkdir /install && \
-  pip install --prefix=/install .
-
-
-# ---- mails ----
-FROM node:20 AS mail-builder
-
-COPY ./src/mail /mail/app
-
-WORKDIR /mail/app
-
-RUN yarn install --frozen-lockfile && \
-    yarn build
-
-
-# ---- static link collector ----
-FROM base AS link-collector
-ARG MEET_STATIC_ROOT=/data/static
-
-RUN apk add \
-  pango \
-  rdfind
-
-# Copy installed python dependencies
-COPY --from=back-builder /install /usr/local
-
-# Copy Meet application (see .dockerignore)
-COPY ./src/backend /app/
-
-WORKDIR /app
-
-# collectstatic
-RUN DJANGO_CONFIGURATION=Build DJANGO_JWT_PRIVATE_SIGNING_KEY=Dummy \
-    python manage.py collectstatic --noinput
-
-# Replace duplicated file by a symlink to decrease the overall size of the
-# final image
-RUN rdfind -makesymlinks true -followsymlinks true -makeresultsfile false ${MEET_STATIC_ROOT}
-
-# ---- Core application image ----
-FROM base AS core
-
-ENV PYTHONUNBUFFERED=1
-
-RUN apk add \
-  gettext \
-  cairo \
-  libffi-dev \
-  gdk-pixbuf \
-  pango \
-  shared-mime-info
-
-
-# Copy entrypoint
-COPY ./docker/files/usr/local/bin/entrypoint /usr/local/bin/entrypoint
-
-# Give the "root" group the same permissions as the "root" user on /etc/passwd
-# to allow a user belonging to the root group to add new users; typically the
-# docker user (see entrypoint).
-RUN chmod g=u /etc/passwd
-
-# Copy installed python dependencies
-COPY --from=back-builder /install /usr/local
-
-# Copy Meet application (see .dockerignore)
-COPY ./src/backend /app/
-
-WORKDIR /app
-
-# We wrap commands run in this container by the following entrypoint that
-# creates a user on-the-fly with the container user ID (see USER) and root group
-# ID.
-ENTRYPOINT [ "/usr/local/bin/entrypoint" ]
-
-# ---- Development image ----
-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
-
-# Uninstall Meet and re-install it in editable mode along with development
-# dependencies
-RUN pip uninstall -y meet
-RUN pip install -e .[dev]
-
-# Restore the un-privileged user running the application
-ARG DOCKER_USER
-USER ${DOCKER_USER}
-
-# Target database host (e.g. database engine following docker compose services
-# name) & port
-ENV DB_HOST=postgresql \
-    DB_PORT=5432
-
-# Run django development server
-CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]
-
-# ---- Production image ----
-FROM core AS backend-production
-
-ARG MEET_STATIC_ROOT=/data/static
-
-# Gunicorn
-RUN mkdir -p /usr/local/etc/gunicorn
-COPY docker/files/usr/local/etc/gunicorn/meet.py /usr/local/etc/gunicorn/meet.py
-
-# Un-privileged user running the application
-ARG DOCKER_USER
-USER ${DOCKER_USER}
-
-# Copy statics
-COPY --from=link-collector ${MEET_STATIC_ROOT} ${MEET_STATIC_ROOT}
-
-# Copy Meet mails
-COPY --from=mail-builder /mail/backend/core/templates/mail /app/core/templates/mail
-
-# The default command runs gunicorn WSGI server in Meet's main module
-CMD ["gunicorn", "-c", "/usr/local/etc/gunicorn/meet.py", "meet.wsgi:application"]

LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-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
-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.

Makefile

@@ -1,310 +0,0 @@
-# /!\ /!\ /!\ /!\ /!\ /!\ /!\ DISCLAIMER /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\
-#
-# This Makefile is only meant to be used for DEVELOPMENT purpose as we are
-# changing the user id that will run in the container.
-#
-# PLEASE DO NOT USE IT FOR YOUR CI/PRODUCTION/WHATEVER...
-#
-# /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\
-#
-# Note to developers:
-#
-# While editing this file, please respect the following statements:
-#
-# 1. Every variable should be defined in the ad hoc VARIABLES section with a
-#    relevant subsection
-# 2. Every new rule should be defined in the ad hoc RULES section with a
-#    relevant subsection depending on the targeted service
-# 3. Rules should be sorted alphabetically within their section
-# 4. When a rule has multiple dependencies, you should:
-#    - duplicate the rule name to add the help string (if required)
-#    - write one dependency per line to increase readability and diffs
-# 5. .PHONY rule statement should be written after the corresponding rule
-# ==============================================================================
-# VARIABLES
-
-BOLD := \033[1m
-RESET := \033[0m
-GREEN := \033[1;32m
-
-
-# -- Database
-
-DB_HOST            = postgresql
-DB_PORT            = 5432
-
-# -- Docker
-# Get the current user ID to use for docker run and docker exec commands
-DOCKER_UID          = $(shell id -u)
-DOCKER_GID          = $(shell id -g)
-DOCKER_USER         = $(DOCKER_UID):$(DOCKER_GID)
-COMPOSE             = DOCKER_USER=$(DOCKER_USER) docker compose
-COMPOSE_EXEC        = $(COMPOSE) exec
-COMPOSE_EXEC_APP    = $(COMPOSE_EXEC) app-dev
-COMPOSE_RUN         = $(COMPOSE) run --rm
-COMPOSE_RUN_APP     = $(COMPOSE_RUN) app-dev
-COMPOSE_RUN_CROWDIN = $(COMPOSE_RUN) crowdin crowdin
-WAIT_DB             = @$(COMPOSE_RUN) dockerize -wait tcp://$(DB_HOST):$(DB_PORT) -timeout 60s
-
-# -- Backend
-MANAGE              = $(COMPOSE_RUN_APP) python manage.py
-MAIL_NPM            = $(COMPOSE_RUN) -w /app/src/mail node npm
-
-# -- Frontend
-PATH_FRONT          = ./src/frontend
-
-# ==============================================================================
-# RULES
-
-default: help
-
-data/media:
-	@mkdir -p data/media
-
-data/static:
-	@mkdir -p data/static
-
-# -- Project
-
-create-env-files: ## Copy the dist env files to env files
-create-env-files: \
-	env.d/development/common \
-	env.d/development/crowdin \
-	env.d/development/postgresql \
-	env.d/development/kc_postgresql
-.PHONY: create-env-files
-
-bootstrap: ## Prepare Docker images for the project
-bootstrap: \
-	data/media \
-	data/static \
-	create-env-files \
-	build \
-	migrate \
-	demo \
-	back-i18n-compile \
-	mails-install \
-	mails-build
-.PHONY: bootstrap
-
-# -- Docker/compose
-build: ## build the app-dev container
-	@$(COMPOSE) build app-dev --no-cache
-.PHONY: build
-
-down: ## stop and remove containers, networks, images, and volumes
-	@$(COMPOSE) down
-.PHONY: down
-
-logs: ## display app-dev logs (follow mode)
-	@$(COMPOSE) logs -f app-dev
-.PHONY: logs
-
-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
-
-status: ## an alias for "docker compose ps"
-	@$(COMPOSE) ps
-.PHONY: status
-
-stop: ## stop the development server using Docker
-	@$(COMPOSE) stop
-.PHONY: stop
-
-# -- Backend
-
-demo: ## flush db then create a demo for load testing purpose
-	@$(MAKE) resetdb
-	@$(MANAGE) create_demo
-.PHONY: demo
-
-# Nota bene: Black should come after isort just in case they don't agree...
-lint: ## lint back-end python sources
-lint: \
-  lint-ruff-format \
-  lint-ruff-check \
-  lint-pylint
-.PHONY: lint
-
-lint-ruff-format: ## format back-end python sources with ruff
-	@echo 'lint:ruff-format started…'
-	@$(COMPOSE_RUN_APP) ruff format .
-.PHONY: lint-ruff-format
-
-lint-ruff-check: ## lint back-end python sources with ruff
-	@echo 'lint:ruff-check started…'
-	@$(COMPOSE_RUN_APP) ruff check . --fix
-.PHONY: lint-ruff-check
-
-lint-pylint: ## lint back-end python sources with pylint only on changed files from main
-	@echo 'lint:pylint started…'
-	@$(COMPOSE_RUN_APP) pylint meet demo core
-.PHONY: lint-pylint
-
-test: ## run project tests
-	@$(MAKE) test-back-parallel
-.PHONY: test
-
-test-back: ## run back-end tests
-	@args="$(filter-out $@,$(MAKECMDGOALS))" && \
-	bin/pytest $${args:-${1}}
-.PHONY: test-back
-
-test-back-parallel: ## run all back-end tests in parallel
-	@args="$(filter-out $@,$(MAKECMDGOALS))" && \
-	bin/pytest -n auto $${args:-${1}}
-.PHONY: test-back-parallel
-
-makemigrations:  ## run django makemigrations for the Meet project.
-	@echo "$(BOLD)Running makemigrations$(RESET)"
-	@$(COMPOSE) up -d postgresql
-	@$(WAIT_DB)
-	@$(MANAGE) makemigrations
-.PHONY: makemigrations
-
-migrate:  ## run django migrations for the Meet project.
-	@echo "$(BOLD)Running migrations$(RESET)"
-	@$(COMPOSE) up -d postgresql
-	@$(WAIT_DB)
-	@$(MANAGE) migrate
-.PHONY: migrate
-
-superuser: ## Create an admin superuser with password "admin"
-	@echo "$(BOLD)Creating a Django superuser$(RESET)"
-	@$(MANAGE) createsuperuser --email admin@example.com --password admin
-.PHONY: superuser
-
-back-i18n-compile: ## compile the gettext files
-	@$(MANAGE) compilemessages --ignore="venv/**/*"
-.PHONY: back-i18n-compile
-
-back-i18n-generate: ## create the .pot files used for i18n
-	@$(MANAGE) makemessages -a --keep-pot
-.PHONY: back-i18n-generate
-
-shell: ## connect to database shell
-	@$(MANAGE) shell #_plus
-.PHONY: dbshell
-
-# -- Database
-
-dbshell: ## connect to database shell
-	docker compose exec app-dev python manage.py dbshell
-.PHONY: dbshell
-
-resetdb: FLUSH_ARGS ?=
-resetdb: ## flush database and create a superuser "admin"
-	@echo "$(BOLD)Flush database$(RESET)"
-	@$(MANAGE) flush $(FLUSH_ARGS)
-	@${MAKE} superuser
-.PHONY: resetdb
-
-env.d/development/common:
-	cp -n env.d/development/common.dist env.d/development/common
-
-env.d/development/postgresql:
-	cp -n env.d/development/postgresql.dist env.d/development/postgresql
-
-env.d/development/kc_postgresql:
-	cp -n env.d/development/kc_postgresql.dist env.d/development/kc_postgresql
-
-# -- Internationalization
-
-env.d/development/crowdin:
-	cp -n env.d/development/crowdin.dist env.d/development/crowdin
-
-crowdin-download: ## Download translated message from Crowdin
-	@$(COMPOSE_RUN_CROWDIN) download -c crowdin/config.yml
-.PHONY: crowdin-download
-
-crowdin-download-sources: ## Download sources from Crowdin
-	@$(COMPOSE_RUN_CROWDIN) download sources -c crowdin/config.yml
-.PHONY: crowdin-download-sources
-
-crowdin-upload: ## Upload source translations to Crowdin
-	@$(COMPOSE_RUN_CROWDIN) upload sources -c crowdin/config.yml
-.PHONY: crowdin-upload
-
-crowdin-upload-translations: ## Upload translations to Crowdin
-	@$(COMPOSE_RUN_CROWDIN) upload translations -c crowdin/config.yml
-.PHONY: crowdin-upload-translations
-
-i18n-compile: ## compile all translations
-i18n-compile: \
-	back-i18n-compile
-.PHONY: i18n-compile
-
-i18n-generate: ## create the .pot files and extract frontend messages
-i18n-generate: \
-	back-i18n-generate \
-	frontend-i18n-generate
-.PHONY: i18n-generate
-
-i18n-download-and-compile: ## download all translated messages and compile them to be used by all applications
-i18n-download-and-compile: \
-  crowdin-download \
-  i18n-compile
-.PHONY: i18n-download-and-compile
-
-i18n-generate-and-upload: ## generate source translations for all applications and upload them to Crowdin
-i18n-generate-and-upload: \
-  i18n-generate \
-  crowdin-upload
-.PHONY: i18n-generate-and-upload
-
-
-# -- Mail generator
-
-mails-build: ## Convert mjml files to html and text
-	@$(MAIL_NPM) run build
-.PHONY: mails-build
-
-mails-build-html-to-plain-text: ## Convert html files to text
-	@$(MAIL_NPM) run build-html-to-plain-text
-.PHONY: mails-build-html-to-plain-text
-
-mails-build-mjml-to-html:	## Convert mjml files to html and text
-	@$(MAIL_NPM) run build-mjml-to-html
-.PHONY: mails-build-mjml-to-html
-
-mails-install: ## install the mail generator
-	@$(MAIL_NPM) install
-.PHONY: mails-install
-
-
-# -- Misc
-clean: ## restore repository state as it was freshly cloned
-	git clean -idx
-.PHONY: clean
-
-help:
-	@echo "$(BOLD)Meet Makefile"
-	@echo "Please use 'make $(BOLD)target$(RESET)' where $(BOLD)target$(RESET) is one of:"
-	@grep -E '^[a-zA-Z0-9_-]+:.*?## .*$$' $(firstword $(MAKEFILE_LIST)) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "$(GREEN)%-30s$(RESET) %s\n", $$1, $$2}'
-.PHONY: help
-
-frontend-i18n-extract: ## Check the frontend code and generate missing translations keys in translation files
-	cd $(PATH_FRONT) && npm run i18n:extract
-.PHONY: frontend-i18n-extract
-
-frontend-i18n-generate: ## Generate the frontend json files used for Crowdin
-frontend-i18n-generate: \
-	crowdin-download-sources \
-	frontend-i18n-extract
-.PHONY: frontend-i18n-generate
-
-# -- K8S
-build-k8s-cluster: ## build the kubernetes cluster using kind
-	./bin/start-kind.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

README.md

@@ -1,157 +0,0 @@
-# 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.
-
-
-### Adding content
-
-You can create a basic demo site by running:
-
-```bash
-$ make demo
-```
-
-Finally, you can check all available Make rules using:
-
-```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`.
-
-
-#### Getting Started
-
-Make sure you have installed:
-- kubectl
-- helm
-- helmfile
-- tilt
-
-To build and start the Kubernetes cluster using Kind:
-```shell
-$ make build-k8s-cluster 
-```
-
-Once the Kubernetes cluster is ready, start the application stack locally:
-```shell
-$ make start-tilt
-or
-$ make start-tilt-keycloak # start stack without Pro Connect, use keycloak
-```
-These commands set up and run your application environment using Tilt for local Kubernetes development.
-
-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
-
-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`:
-
-```yaml
-...
-
-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
-
-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
-
-This work is released under the MIT License (see [LICENSE](./LICENSE)).

UPGRADE.md

@@ -1,17 +0,0 @@
-# Upgrade
-
-All instructions to upgrade this project from one release to the next will be
-documented in this file. Upgrades must be run sequentially, meaning you should
-not skip minor/major releases while upgrading (fix releases can be skipped).
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-For most upgrades, you just need to run the django migrations with
-the following command inside your docker container:
-
-`python manage.py migrate`
-
-(Note : in your development environment, you can `make migrate`.)
-
-## [Unreleased]

bin/Tiltfile

@@ -1,67 +0,0 @@
-load('ext://uibutton', 'cmd_button', 'bool_input', 'location')
-load('ext://namespace', 'namespace_create', 'namespace_inject')
-namespace_create('meet')
-docker_build(
-    'localhost:5001/meet-backend:latest',
-    context='..',
-    dockerfile='../Dockerfile',
-    only=['./src/backend', './src/mail', './docker'],
-    target = 'backend-production',
-    live_update=[
-        sync('../src/backend', '/app'),
-        run(
-            'pip install -r /app/requirements.txt',
-            trigger=['./api/requirements.txt']
-        )
-    ]
-)
-
-docker_build(
-    'localhost:5001/meet-frontend:latest',
-    context='..',
-    dockerfile='../src/frontend/Dockerfile',
-    only=['./src/frontend', './docker', './.dockerignore'],
-    target = 'meet-dev',
-    live_update=[
-        sync('../src/frontend', '/home/frontend'),
-    ]
-)
-
-docker_build(
-    'localhost:5001/meet-summary:latest',
-    context='../src/summary',
-    dockerfile='../src/summary/Dockerfile',
-    only=['.', '../../docker', '../../.dockerignore'],
-    target = 'production',
-    live_update=[
-        sync('../src/summary', '/home/summary'),
-    ]
-)
-
-k8s_yaml(local('cd ../src/helm && helmfile -n meet -e ${DEV_ENV:-dev} template .'))
-
-migration = '''
-set -eu
-# get k8s pod name from tilt resource name
-POD_NAME="$(tilt get kubernetesdiscovery meet-backend -ojsonpath='{.status.pods[0].name}')"
-kubectl -n meet exec "$POD_NAME" -- python manage.py makemigrations
-'''
-cmd_button('Make migration',
-           argv=['sh', '-c', migration],
-           resource='meet-backend',
-           icon_name='developer_board',
-           text='Run makemigration',
-)
-
-pod_migrate = '''
-set -eu
-# get k8s pod name from tilt resource name
-POD_NAME="$(tilt get kubernetesdiscovery meet-backend -ojsonpath='{.status.pods[0].name}')"
-kubectl -n meet exec "$POD_NAME" -- python manage.py migrate --no-input
-'''
-cmd_button('Migrate db',
-           argv=['sh', '-c', pod_migrate],
-           resource='meet-backend',
-           icon_name='developer_board',
-           text='Run database migration',
-)

bin/_config.sh

@@ -1,93 +0,0 @@
-#!/usr/bin/env bash
-
-set -eo pipefail
-
-REPO_DIR="$(cd "$( dirname "${BASH_SOURCE[0]}" )/.." && pwd)"
-UNSET_USER=0
-
-COMPOSE_FILE="${REPO_DIR}/compose.yml"
-COMPOSE_PROJECT="meet"
-
-
-# _set_user: set (or unset) default user id used to run docker commands
-#
-# usage: _set_user
-#
-# You can override default user ID (the current host user ID), by defining the
-# USER_ID environment variable.
-#
-# To avoid running docker commands with a custom user, please set the
-# $UNSET_USER environment variable to 1.
-function _set_user() {
-
-    if [ $UNSET_USER -eq 1 ]; then
-        USER_ID=""
-        return
-    fi
-
-    # USER_ID = USER_ID or `id -u` if USER_ID is not set
-    USER_ID=${USER_ID:-$(id -u)}
-
-    echo "🙋(user) ID: ${USER_ID}"
-}
-
-# docker_compose: wrap docker compose command
-#
-# usage: docker_compose [options] [ARGS...]
-#
-# options: docker compose command options
-# ARGS   : docker compose command arguments
-function _docker_compose() {
-
-    echo "🐳(compose) project: '${COMPOSE_PROJECT}' file: '${COMPOSE_FILE}'"
-    docker compose \
-        -p "${COMPOSE_PROJECT}" \
-        -f "${COMPOSE_FILE}" \
-        --project-directory "${REPO_DIR}" \
-        "$@"
-}
-
-# _dc_run: wrap docker compose run command
-#
-# usage: _dc_run [options] [ARGS...]
-#
-# options: docker compose run command options
-# ARGS   : docker compose run command arguments
-function _dc_run() {
-    _set_user
-
-    user_args="--user=$USER_ID"
-    if [ -z $USER_ID ]; then
-        user_args=""
-    fi
-
-    _docker_compose run --rm $user_args "$@"
-}
-
-# _dc_exec: wrap docker compose exec command
-#
-# usage: _dc_exec [options] [ARGS...]
-#
-# options: docker compose exec command options
-# ARGS   : docker compose exec command arguments
-function _dc_exec() {
-    _set_user
-
-    echo "🐳(compose) exec command: '\$@'"
-
-    user_args="--user=$USER_ID"
-    if [ -z $USER_ID ]; then
-        user_args=""
-    fi
-
-    _docker_compose exec $user_args "$@"
-}
-
-# _django_manage: wrap django's manage.py command with docker compose
-#
-# usage : _django_manage [ARGS...]
-#
-# ARGS : django's manage.py command arguments
-function _django_manage() {
-    _dc_run "app-dev" python manage.py "$@"
-}

bin/compose

@@ -1,6 +0,0 @@
-#!/usr/bin/env bash
-
-# shellcheck source=bin/_config.sh
-source "$(dirname "${BASH_SOURCE[0]}")/_config.sh"
-
-_docker_compose "$@"

bin/install-hooks.sh

@@ -1,30 +0,0 @@
-#!/bin/bash
-
-mkdir -p "$(dirname -- "${BASH_SOURCE[0]}")/../.git/hooks/"
-PRE_COMMIT_FILE="$(dirname -- "${BASH_SOURCE[0]}")/../.git/hooks/pre-commit"
-
-cat <<'EOF' >$PRE_COMMIT_FILE
-#!/bin/bash
-
-# directories containing potential secrets
-DIRS="."
-
-bold=$(tput bold)
-normal=$(tput sgr0)
-
-# allow to read user input, assigns stdin to keyboard
-exec </dev/tty
-
-for d in $DIRS; do
-	# find files containing secrets that should be encrypted
-	for f in $(find "${d}" -type f -regex ".*\.enc\..*"); do
-		if ! $(grep -q "unencrypted_suffix" $f); then
-			printf '\xF0\x9F\x92\xA5 '
-			echo "File $f has non encrypted secrets!"
-			exit 1
-		fi
-	done
-done
-EOF
-
-chmod +x $PRE_COMMIT_FILE

bin/manage

@@ -1,6 +0,0 @@
-#!/usr/bin/env bash
-
-# shellcheck source=bin/_config.sh
-source "$(dirname "${BASH_SOURCE[0]}")/_config.sh"
-
-_django_manage "$@"

bin/pytest

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-
-source "$(dirname "${BASH_SOURCE[0]}")/_config.sh"
-
-_dc_run \
-    -e DJANGO_CONFIGURATION=Test \
-    app-dev \
-    pytest "$@"

bin/start-kind.sh

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

bin/update-git-submodule.sh

@@ -1,4 +0,0 @@
-#!/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 +0,0 @@
-#!/bin/bash
-
-find . -name "*.enc.*" -exec sops updatekeys -y {} \;

bin/update-openapi-schema

@@ -1,12 +0,0 @@
-#!/usr/bin/env bash
-
-source "$(dirname "${BASH_SOURCE[0]}")/_config.sh"
-
-_dc_run \
-    -e DJANGO_CONFIGURATION=Test \
-    app-dev \
-    python manage.py spectacular \
-    --api-version 'v1.0' \
-    --urlconf 'meet.api_urls' \
-    --format openapi-json \
-    --file /app/core/tests/swagger/swagger.json

bin/validate-helm-configuration.sh

@@ -1,13 +0,0 @@
-#!/bin/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

compose.yml

@@ -1,174 +0,0 @@
-
-services:
-  postgresql:
-    image: postgres:16
-    env_file:
-      - env.d/development/postgresql
-    ports:
-      - "15432:5432"
-
-  redis:
-    image: redis:5
-
-  mailcatcher:
-    image: sj26/mailcatcher:latest
-    ports:
-      - "1081:1080"
-
-  app-dev:
-    build:
-      context: .
-      target: backend-development
-      args:
-        DOCKER_USER: ${DOCKER_USER:-1000}
-    user: ${DOCKER_USER:-1000}
-    image: meet:backend-development
-    environment:
-      - PYLINTHOME=/app/.pylint.d
-      - DJANGO_CONFIGURATION=Development
-    env_file:
-      - env.d/development/common
-      - env.d/development/postgresql
-    ports:
-      - "8071:8000"
-    volumes:
-      - ./src/backend:/app
-      - ./data/static:/data/static
-    depends_on:
-        - postgresql
-        - mailcatcher
-        - redis
-        - nginx
-        - livekit
-  
-  celery-dev:
-    user: ${DOCKER_USER:-1000}
-    image: meet:backend-development
-    command: ["celery", "-A", "meet.celery_app", "worker", "-l", "DEBUG"]
-    environment:
-      - DJANGO_CONFIGURATION=Development
-    env_file:
-      - env.d/development/common
-      - env.d/development/postgresql
-    volumes:
-      - ./src/backend:/app
-      - ./data/static:/data/static
-    depends_on:
-      - app-dev
-
-  app:
-    build:
-      context: .
-      target: backend-production
-      args:
-        DOCKER_USER: ${DOCKER_USER:-1000}
-    user: ${DOCKER_USER:-1000}
-    image: meet:backend-production
-    environment:
-      - DJANGO_CONFIGURATION=Demo
-    env_file:
-      - env.d/development/common
-      - env.d/development/postgresql
-    depends_on:
-      - postgresql
-      - redis
-      - livekit
-
-  celery:
-    user: ${DOCKER_USER:-1000}
-    image: meet:backend-production
-    command: ["celery", "-A", "meet.celery_app", "worker", "-l", "INFO"]
-    environment:
-      - DJANGO_CONFIGURATION=Demo
-    env_file:
-      - env.d/development/common
-      - env.d/development/postgresql
-    depends_on:
-      - app
-
-  nginx:
-    image: nginx:1.25
-    ports:
-      - "8083:8083"
-    volumes:
-      - ./docker/files/etc/nginx/conf.d:/etc/nginx/conf.d:ro
-    depends_on:
-      - keycloak
-
-  dockerize:
-    image: jwilder/dockerize
-
-  crowdin:
-    image: crowdin/cli:4.0.0
-    volumes:
-      - ".:/app"
-    env_file:
-      - env.d/development/crowdin
-    user: "${DOCKER_USER:-1000}"
-    working_dir: /app
-
-  node:
-    image: node:18
-    user: "${DOCKER_USER:-1000}"
-    environment:
-      HOME: /tmp
-    volumes:
-      - ".:/app"
-
-  kc_postgresql:
-    image: postgres:14.3
-    ports:
-      - "5433:5432"
-    env_file:
-      - env.d/development/kc_postgresql
-
-  keycloak:
-    image: quay.io/keycloak/keycloak:20.0.1
-    volumes:
-      - ./docker/auth/realm.json:/opt/keycloak/data/import/realm.json
-    command:
-      - start-dev
-      - --features=preview
-      - --import-realm
-      - --proxy=edge
-      - --hostname-url=http://localhost:8083
-      - --hostname-admin-url=http://localhost:8083/
-      - --hostname-strict=false
-      - --hostname-strict-https=false
-    environment:
-      KEYCLOAK_ADMIN: admin
-      KEYCLOAK_ADMIN_PASSWORD: admin
-      KC_DB: postgres
-      KC_DB_URL_HOST: kc_postgresql
-      KC_DB_URL_DATABASE: keycloak
-      KC_DB_PASSWORD: pass
-      KC_DB_USERNAME: meet
-      KC_DB_SCHEMA: public
-      PROXY_ADDRESS_FORWARDING: 'true'
-    ports:
-      - "8080:8080"
-    depends_on:
-      - kc_postgresql
-
-  livekit:
-    image: livekit/livekit-server
-    entrypoint: /livekit-server --dev --bind 0.0.0.0 --config ./config.yaml
-    ports:
-      - "7880:7880"
-      - "7881:7881"
-      - "7882:7882/udp"
-    volumes:
-      - ./docker/livekit/config/livekit-server.yaml:/config.yaml
-    depends_on:
-      - redis
-      - livekit-egress
-
-  livekit-egress:
-      image: livekit/egress
-      environment:
-        EGRESS_CONFIG_FILE: ./livekit-egress.yaml
-      volumes:
-        - ./docker/livekit/config/livekit-egress.yaml:/livekit-egress.yaml
-        - ./docker/livekit/out:/out
-      depends_on:
-        - redis

crowdin/config.yml

@@ -1,30 +0,0 @@
-#
-# Your crowdin's credentials
-#
-api_token_env: CROWDIN_PERSONAL_TOKEN
-project_id_env: CROWDIN_PROJECT_ID
-base_path_env: CROWDIN_BASE_PATH
-
-#
-# Choose file structure in crowdin
-# e.g. true or false
-#
-preserve_hierarchy: true
-
-#
-# Files configuration
-#
-files:
-  [
-    {
-      source: "src/backend/locale/django.pot",
-      dest: "/backend-meet.pot",
-      translation: "src/backend/locale/%locale_with_underscore%/LC_MESSAGES/django.po",
-    },
-    {
-      source: "src/frontend/src/locales/fr/**/*",
-      translation: "src/frontend/src/locales/%two_letters_code%/**/%original_file_name%",
-      dest: "/%original_file_name%",
-      skip_untranslated_strings: true,
-    },
-  ]

docker/files/etc/nginx/conf.d/default.conf

@@ -1,13 +0,0 @@
-
-server {
-    listen 8083;
-    server_name localhost;
-    charset utf-8;
-
-    location / {
-        proxy_pass http://keycloak:8080;
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-    }
-}

docker/files/usr/local/bin/entrypoint

@@ -1,35 +0,0 @@
-#!/bin/sh
-#
-# The container user (see USER in the Dockerfile) is an un-privileged user that
-# does not exists and is not created during the build phase (see Dockerfile).
-# Hence, we use this entrypoint to wrap commands that will be run in the
-# container to create an entry for this user in the /etc/passwd file.
-#
-# The following environment variables may be passed to the container to
-# customize running user account:
-#
-#   * USER_NAME: container user name (default: default)
-#   * HOME     : container user home directory (default: none)
-#
-# To pass environment variables, you can either use the -e option of the docker run command:
-#
-#     docker run --rm -e USER_NAME=foo -e HOME='/home/foo' impress:latest python manage.py migrate
-#
-# or define new variables in an environment file to use with docker or docker compose:
-#
-#     # env.d/production
-#     USER_NAME=foo
-#     HOME=/home/foo
-#
-#     docker run --rm --env-file env.d/production impress:latest python manage.py migrate
-#
-
-echo "🐳(entrypoint) creating user running in the container..."
-if ! whoami > /dev/null 2>&1; then
-  if [ -w /etc/passwd ]; then
-    echo "${USER_NAME:-default}:x:$(id -u):$(id -g):${USER_NAME:-default} user:${HOME}:/sbin/nologin" >> /etc/passwd
-  fi
-fi
-
-echo "🐳(entrypoint) running your command: ${*}"
-exec "$@"

docker/files/usr/local/etc/gunicorn/meet.py

@@ -1,16 +0,0 @@
-# Gunicorn-django settings
-bind = ["0.0.0.0:8000"]
-name = "meet"
-python_path = "/app"
-
-# Run
-graceful_timeout = 90
-timeout = 90
-workers = 3
-
-# Logging
-# Using '-' for the access log file makes gunicorn log accesses to stdout
-accesslog = "-"
-# Using '-' for the error log file makes gunicorn log errors to stderr
-errorlog = "-"
-loglevel = "info"

docker/livekit/config/livekit-egress.yaml

@@ -1,7 +0,0 @@
-log_level: debug
-api_key: devkey
-api_secret: secret
-ws_url: "ws://livekit:7880"
-insecure: true
-redis:
-  address: redis:6379

docker/livekit/config/livekit-server.yaml

@@ -1,5 +0,0 @@
-log_level: debug
-redis:
-  address: redis:6379
-keys:
-  devkey: secret

docker/livekit/egress-example/room-composite-file.json

@@ -1,9 +0,0 @@
-{
-  "room_name": "your-room-name",
-  "layout": "speaker-dark",
-  "file_outputs": [
-    {
-      "filepath": "/out/"
-    }
-  ]
-}

docs/egress.md

@@ -1,81 +0,0 @@
-# LiveKit Egress
-
-LiveKit offers Universal Egress, designed to provide universal exports of LiveKit sessions or tracks to a file or stream data.
-It is kept in a separate system to keep the load off the [Single Forwarding Unit (SFU)](https://docs.livekit.io/reference/internals/livekit-sfu/) and avoid impacting real-time audio or video performance/quality.
-
-## Getting started
-
-### Prerequisite
-
-1. **Verify Services**: Ensure the LiveKit server and Egress service are both up and running.
-2. **Install CLI**: Confirm that the LiveKit CLI utility is installed on your system.
-3. **Set Permissions**: Since the Egress service does not run as the root user, you need to grant write permissions to all users for the output directory. Update the permissions of the `docker/livekit/out` folder before starting the docker-compose stack:
-
-```bash
-$ chmod o+w ./docker/livekit/out
-```
-
-### Make a recording
-
-LiveKit provides examples for creating Egress requests, which you can find [here](https://github.com/livekit/livekit-cli/tree/main/cmd/livekit-cli/examples). One of these examples has been added to the repository under `docker/livekit/egress-example`.
-
-Follow these steps to start an Egress request:
-
-1. **Create a Room**: Create a room either through the frontend or using the `livekit-cli` command.
-2. **Retrieve Room Name**: Get the room's name (e.g., the UUID4 in the URL from the frontend).
-3. **Update Configuration**: Edit the `docker/livekit/egress-example/room-composite-file.json` file with your room's name.
-4. **Start Egress Request**: Initiate a new Egress request.
-```bash
-$ livekit-cli start-room-composite-egress --request ./docker/livekit/egress-example/room-composite-file.json
-
-Using default project meet
-EgressID: EG_XXXXXXXXXXXX Status: EGRESS_STARTING
-```
-
-You can list running Egress:
-
-```Bash
-$ livekit-cli list-egress
-
-Using default project meet
-+-----------------+---------------+----------------+--------------------------------------+--------------------------------+-------+
-|    EGRESSID     |    STATUS     |      TYPE      |                SOURCE                |           STARTED AT           | ERROR |
-+-----------------+---------------+----------------+--------------------------------------+--------------------------------+-------+
-| EG_XXXXXXXXXXXX | EGRESS_ACTIVE | room_composite | your-room-name-XXXXXXXXXXX-XXXXXXXXX | 2024-07-05 18:11:37.073847924  |       |
-|                 |               |                |                                      | +0200 CEST                     |       |
-+-----------------+---------------+----------------+--------------------------------------+--------------------------------+-------+
-```
-
-You can stop the Egress at any time once your recording is finished:
-```Bash
-$ livekit-cli stop-egress --id EG_XXXXXXXXXXXX
-
-Using default project meet
-Stopping Egress EG_XXXXXXXXXXXX
-```
-
-The Egress should be marked as completed:
-```bash
-$ livekit-cli list-egress
-
-Using default project meet
-+-----------------+-----------------+----------------+--------------------------------------+--------------------------------+-------+
-|    EGRESSID     |     STATUS      |      TYPE      |                SOURCE                |           STARTED AT           | ERROR |
-+-----------------+-----------------+----------------+--------------------------------------+--------------------------------+-------+
-| EG_XXXXXXXXXXXX | EGRESS_COMPLETE | room_composite | your-room-name-XXXXXXXXXXX-XXXXXXXXX | 2024-07-05 18:11:37.073847924  |       |
-|                 |                 |                |                                      | +0200 CEST                     |       |
-+-----------------+-----------------+----------------+--------------------------------------+--------------------------------+-------+
-```
-
-
-Finally, you should find two new files in the `./docker/livekit/out directory`: an `.mp4` recording and its associated metadata in a `.json` file:
-```bash
-$ ls ./docker/livekit/out
-
-your-room-name-YYYY-MM-DDTHHMMSS.mp4
-your-room-name-YYYY-MM-DDTHHMMSS.mp4.json
-```
-
-### Resources
-
-[Official Egress repository](https://github.com/livekit/egress)

docs/release.md

@@ -1,65 +0,0 @@
-# Releasing a new version
-
-Whenever we are cooking a new release (e.g. `4.18.1`) we should follow a standard procedure described below:
-
-1.  Create a new branch named: `release/4.18.1`.
-   2.  Bump the release number for backend project, frontend projects, and Helm files:
-
-       - for backend, update the version number by hand in `pyproject.toml`,
-       - for each frontend projects (`src/frontend`, `src/mail`), run `npm version 4.18.1` in their directory. This will update both their `package.json` and `package-lock.json` for you,
-       - for Helm, update Docker image tag in files located at `src/helm/env.d` for both `preprod` and `production` environments:
-
-         ```yaml
-         image:
-           repository: lasuite/meet-backend
-           pullPolicy: Always
-           tag: "v4.18.1" # Replace with your new version number, without forgetting the "v" prefix
-      
-         ...
-      
-         frontend:
-           image:
-             repository: lasuite/meet-frontend
-             pullPolicy: Always
-             tag: "v4.18.1" # Replace with your new version number, without forgetting the "v" prefix
-         ```
-
-         The new images don't exist _yet_: they will be created automatically later in the process.
-
-3.  ~~Update the project's `Changelog` following the [keepachangelog](https://keepachangelog.com/en/0.3.0/) recommendations~~ _we don't keep a changelog yet for now as the project is still in its infancy. Soon™!_
-4.  Commit your changes with the following format: the 🔖 release emoji, the type of release (patch/minor/patch) and the release version:
-
-    ```text
-    🔖(minor) bump release to 4.18.0
-    ```
-
-5.  Open a pull request, wait for an approval from your peers and merge it.
-6.  Checkout and pull changes from the `main` branch to ensure you have the latest updates.
-7.  Tag and push your commit:
-
-    ```bash
-    git tag v4.18.1 && git push origin --tags
-    ```
-
-    Doing this triggers the CI and tells it to build the new Docker image versions that you targeted earlier in the Helm files.
-
-8.  Ensure the new [backend](https://hub.docker.com/r/lasuite/meet-frontend/tags) and [frontend](https://hub.docker.com/r/lasuite/meet-frontend/tags) image tags are on Docker Hub.
-9.  The release is now done!
-
-# Deploying
-
-> [!TIP]
-> The `staging` platform is deployed automatically with every update of the `main` branch.
-
-Making a new release doesn't publish it automatically in production.
-
-Deployment is done by ArgoCD. ArgoCD checks for the `production` tag and automatically deploys the production platform with the targeted commit.
-
-To publish, we mark the commit we want with the `production` tag. ArgoCD is then notified that the tag has changed. It then deploys the Docker image tags specified in the Helm files of the targeted commit.
-
-To publish the release you just made:
-
-```bash
-git tag --force production v4.18.1
-git push --force origin production
-```

env.d/development/common.dist

@@ -1,44 +0,0 @@
-# Django
-DJANGO_ALLOWED_HOSTS=*
-DJANGO_SECRET_KEY=ThisIsAnExampleKeyForDevPurposeOnly
-DJANGO_SETTINGS_MODULE=meet.settings
-DJANGO_SUPERUSER_PASSWORD=admin
-
-# Python
-PYTHONPATH=/app
-
-# Meet settings
-
-# Mail
-DJANGO_EMAIL_HOST="mailcatcher"
-DJANGO_EMAIL_PORT=1025
-
-# Backend url
-MEET_BASE_URL="http://localhost:8072"
-
-# Media
-STORAGES_STATICFILES_BACKEND=django.contrib.staticfiles.storage.StaticFilesStorage
-
-# OIDC
-OIDC_OP_JWKS_ENDPOINT=http://nginx:8083/realms/meet/protocol/openid-connect/certs
-OIDC_OP_AUTHORIZATION_ENDPOINT=http://localhost:8083/realms/meet/protocol/openid-connect/auth
-OIDC_OP_TOKEN_ENDPOINT=http://nginx:8083/realms/meet/protocol/openid-connect/token
-OIDC_OP_USER_ENDPOINT=http://nginx:8083/realms/meet/protocol/openid-connect/userinfo
-
-OIDC_RP_CLIENT_ID=meet
-OIDC_RP_CLIENT_SECRET=ThisIsAnExampleKeyForDevPurposeOnly
-OIDC_RP_SIGN_ALGO=RS256
-OIDC_RP_SCOPES="openid email"
-
-LOGIN_REDIRECT_URL=http://localhost:3000
-LOGIN_REDIRECT_URL_FAILURE=http://localhost:3000
-LOGOUT_REDIRECT_URL=http://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://localhost:7880
-ALLOW_UNREGISTERED_ROOMS=False

env.d/development/common.e2e.dist

@@ -1,3 +0,0 @@
-# For the CI job test-e2e
-SUSTAINED_THROTTLE_RATES="200/hour"
-BURST_THROTTLE_RATES="200/minute"

env.d/development/crowdin.dist

@@ -1,3 +0,0 @@
-CROWDIN_PERSONAL_TOKEN=Your-Api-Token
-CROWDIN_PROJECT_ID=Your-Project-Id
-CROWDIN_BASE_PATH=/app

env.d/development/kc_postgresql.dist

@@ -1,11 +0,0 @@
-# Postgresql db container configuration
-POSTGRES_DB=keycloak
-POSTGRES_USER=meet
-POSTGRES_PASSWORD=pass
-
-# App database configuration
-DB_HOST=kc_postgresql
-DB_NAME=keycloak
-DB_USER=meet
-DB_PASSWORD=pass
-DB_PORT=5433

env.d/development/postgresql.dist

@@ -1,11 +0,0 @@
-# Postgresql db container configuration
-POSTGRES_DB=meet
-POSTGRES_USER=dinum
-POSTGRES_PASSWORD=pass
-
-# App database configuration
-DB_HOST=postgresql
-DB_NAME=meet
-DB_USER=dinum
-DB_PASSWORD=pass
-DB_PORT=5432

gitlint/gitlint_emoji.py

@@ -1,37 +0,0 @@
-"""
-Gitlint extra rule to validate that the message title is of the form
-"<gitmoji>(<scope>) <subject>"
-"""
-from __future__ import unicode_literals
-
-import re
-
-import requests
-
-from gitlint.rules import CommitMessageTitle, LineRule, RuleViolation
-
-
-class GitmojiTitle(LineRule):
-    """
-    This rule will enforce that each commit title is of the form "<gitmoji>(<scope>) <subject>"
-    where gitmoji is an emoji from the list defined in https://gitmoji.carloscuesta.me and
-    subject should be all lowercase
-    """
-
-    id = "UC1"
-    name = "title-should-have-gitmoji-and-scope"
-    target = CommitMessageTitle
-
-    def validate(self, title, _commit):
-        """
-        Download the list possible gitmojis from the project's github repository and check that
-        title contains one of them.
-        """
-        gitmojis = requests.get(
-            "https://raw.githubusercontent.com/carloscuesta/gitmoji/master/packages/gitmojis/src/gitmojis.json"
-        ).json()["gitmojis"]
-        emojis = [item["emoji"] for item in gitmojis]
-        pattern = r"^({:s})\(.*\)\s[a-z].*$".format("|".join(emojis))
-        if not re.search(pattern, title):
-            violation_msg = 'Title does not match regex "<gitmoji>(<scope>) <subject>"'
-            return [RuleViolation(self.id, violation_msg, title)]

index.yaml

@@ -0,0 +1,156 @@
+apiVersion: v1
+entries:
+  meet:
+  - apiVersion: v2
+    created: "2026-03-10T15:12:24.633530868Z"
+    digest: b4154ff27f2d93f2f541a77c85c055a4bb48352e7500ca32a46c320efcc87237
+    name: meet
+    type: application
+    urls:
+    - https://suitenumerique.github.io/meet/meet-0.0.17.tgz
+    version: 0.0.17
+  - apiVersion: v2
+    created: "2026-03-04T20:31:32.525156649Z"
+    digest: df824cf7fe4b6d64d14095cbf3a9449e90e964d052c4c30120646cfb287a22cf
+    name: meet
+    type: application
+    urls:
+    - https://suitenumerique.github.io/meet/meet-0.0.16.tgz
+    version: 0.0.16
+  - apiVersion: v2
+    created: "2025-11-12T13:38:34.67890105Z"
+    digest: 75d3963d2806eafa53aeb41d2dc8802db7b6d81e965206e7bb15cef1e0d8091f
+    name: meet
+    type: application
+    urls:
+    - https://suitenumerique.github.io/meet/meet-0.0.15.tgz
+    version: 0.0.15
+  - apiVersion: v2
+    created: "2025-10-17T10:18:46.887985621Z"
+    digest: 892997fc0aa0d87f0777c145363b08116b3b2cca17236020271069ad48bdba24
+    name: meet
+    type: application
+    urls:
+    - https://suitenumerique.github.io/meet/meet-0.0.14.tgz
+    version: 0.0.14
+  - apiVersion: v2
+    created: "2025-10-02T23:19:02.85180312Z"
+    digest: 043d1b99bd86f7d66a3954b5acfb77d41290d0f1f32f9f45d88d66f6f620ea3c
+    name: meet
+    type: application
+    urls:
+    - https://suitenumerique.github.io/meet/meet-0.0.13.tgz
+    version: 0.0.13
+  - apiVersion: v2
+    created: "2025-10-04T22:46:56.973253204Z"
+    digest: 7328875986ee7cf316d140abd4d8e31409a97d43b8897bf355841bcbdbc1142b
+    name: meet
+    type: application
+    urls:
+    - https://suitenumerique.github.io/meet/meet-0.0.13-beta.1.tgz
+    version: 0.0.13-beta.1
+  - apiVersion: v2
+    created: "2025-09-17T23:44:37.310135884Z"
+    digest: 8c014e51c0f8ebdcdc018017f1c4a7855eccb5d06bc908c10685ea26cf8b015c
+    name: meet
+    type: application
+    urls:
+    - https://suitenumerique.github.io/meet/meet-0.0.12.tgz
+    version: 0.0.12
+  - apiVersion: v2
+    created: "2025-09-04T17:31:23.753076005Z"
+    digest: e7369ba33b22a28a0f294584e1486caa8ac337e742f75b6cadf675d183c28950
+    name: meet
+    type: application
+    urls:
+    - https://suitenumerique.github.io/meet/meet-0.0.11.tgz
+    version: 0.0.11
+  - apiVersion: v2
+    created: "2025-10-02T09:46:19.735559438Z"
+    digest: 9c220d1ffa6e9402fb56b2f9ae71686c6a391a109065b1997741c30768fbafe7
+    name: meet
+    type: application
+    urls:
+    - https://suitenumerique.github.io/meet/meet-0.0.11-debug.tgz
+    version: 0.0.11-debug
+  - apiVersion: v2
+    created: "2025-06-20T16:17:43.527962928Z"
+    digest: 1422bf9be4d1825abaad9d74533ae62cfc5d1c5c507c54cfcc5a9d91c8d8d7c7
+    name: meet
+    type: application
+    urls:
+    - https://suitenumerique.github.io/meet/meet-0.0.10.tgz
+    version: 0.0.10
+  - apiVersion: v2
+    created: "2025-06-06T09:30:32.961691002Z"
+    digest: d1e0d6daf30496c9a6de15e3ab2bb1d5b2bbd5cd37b4de54b3a072a4343ef720
+    name: meet
+    type: application
+    urls:
+    - https://suitenumerique.github.io/meet/meet-0.0.9.tgz
+    version: 0.0.9
+  - apiVersion: v2
+    created: "2025-05-23T17:11:42.125888078Z"
+    digest: aa243ce4ac3847eb8e8be181869893cd0917562c77039494fc6d0af5e72af6fc
+    name: meet
+    type: application
+    urls:
+    - https://suitenumerique.github.io/meet/meet-0.0.8.tgz
+    version: 0.0.8
+  - apiVersion: v2
+    created: "2025-05-15T12:53:03.926017693Z"
+    digest: c544aeb615f1db756ac06b18bec4342f6d0eab02dafcd6df8943dd010026f070
+    name: meet
+    type: application
+    urls:
+    - https://suitenumerique.github.io/meet/meet-0.0.7.tgz
+    version: 0.0.7
+  - apiVersion: v2
+    created: "2025-05-12T12:34:02.090910553Z"
+    digest: bf1bb8c01dcdbe59bf4dfe662d720e63d58396192e46ea29b00f8a91fccbc465
+    name: meet
+    type: application
+    urls:
+    - https://suitenumerique.github.io/meet/meet-0.0.6.tgz
+    version: 0.0.6
+  - apiVersion: v2
+    created: "2025-04-22T14:39:26.901507628Z"
+    digest: bad0c45394827f5c7ac637047bce717f168e253b1514a4c075947360a9863076
+    name: meet
+    type: application
+    urls:
+    - https://suitenumerique.github.io/meet/meet-0.0.5.tgz
+    version: 0.0.5
+  - apiVersion: v2
+    created: "2025-04-18T07:59:32.528327321Z"
+    digest: c2482a6cdb3c4d046c9a6abc57b7b0e9432fa99cae10b450622447ae32f493c3
+    name: meet
+    type: application
+    urls:
+    - https://suitenumerique.github.io/meet/meet-0.0.4.tgz
+    version: 0.0.4
+  - apiVersion: v2
+    created: "2025-02-07T16:54:04.557074469Z"
+    digest: 3c9108036e9d8ef8b9cdb7e03fefdf9eac70f7a3bfa433b3ff1dc7a684aac8fc
+    name: meet
+    type: application
+    urls:
+    - https://suitenumerique.github.io/meet/meet-0.0.3.tgz
+    version: 0.0.3
+  - apiVersion: v2
+    created: "2025-02-05T21:24:38.620673768Z"
+    digest: 94379bd9f36dd24bea7a9d725249fc6693238eedcc714fa9b4de40c9577eabfe
+    name: meet
+    type: application
+    urls:
+    - https://suitenumerique.github.io/meet/meet-0.0.2.tgz
+    version: 0.0.2
+  - apiVersion: v2
+    created: "2025-01-02T16:53:42.251730484Z"
+    digest: 38e6901cb2815a41387efe03909470834c9cd64c818aaa05f3f2a3f5f075c74c
+    name: meet
+    type: application
+    urls:
+    - https://suitenumerique.github.io/meet/meet-0.0.1.tgz
+    version: 0.0.1
+generated: "2026-03-10T15:12:24.631489028Z"

renovate.json

@@ -1,21 +0,0 @@
-{
-  "extends": ["github>numerique-gouv/renovate-configuration"],
-  "dependencyDashboard": true,
-  "labels": ["dependencies", "noChangeLog"],
-  "packageRules": [
-    {
-      "enabled": false,
-      "groupName": "ignored python dependencies",
-      "matchManagers": ["pep621"],
-      "matchPackageNames": []
-    },
-    {
-      "enabled": false,
-      "groupName": "ignored js dependencies",
-      "matchManagers": ["npm"],
-      "matchPackageNames": [
-        "eslint"
-      ]
-    }
-  ]
-}

src/backend/.pylintrc

@@ -1,472 +0,0 @@
-[MASTER]
-
-# A comma-separated list of package or module names from where C extensions may
-# be loaded. Extensions are loading into the active Python interpreter and may
-# run arbitrary code
-extension-pkg-whitelist=
-
-# Add files or directories to the blacklist. They should be base names, not
-# paths.
-ignore=migrations
-
-# Add files or directories matching the regex patterns to the blacklist. The
-# regex matches against base names, not paths.
-ignore-patterns=
-
-# Python code to execute, usually for sys.path manipulation such as
-# pygtk.require().
-#init-hook=
-
-# Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the
-# number of processors available to use.
-jobs=0
-
-# List of plugins (as comma separated values of python modules names) to load,
-# usually to register additional checkers.
-load-plugins=pylint_django,pylint.extensions.no_self_use
-
-# Pickle collected data for later comparisons.
-persistent=yes
-
-# Specify a configuration file.
-#rcfile=
-
-# When enabled, pylint would attempt to guess common misconfiguration and emit
-# user-friendly hints instead of false-positive error messages
-suggestion-mode=yes
-
-# Allow loading of arbitrary C extensions. Extensions are imported into the
-# active Python interpreter and may run arbitrary code.
-unsafe-load-any-extension=no
-
-
-[MESSAGES CONTROL]
-
-# Only show warnings with the listed confidence levels. Leave empty to show
-# all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED
-confidence=
-
-# Disable the message, report, category or checker with the given id(s). You
-# can either give multiple identifiers separated by comma (,) or put this
-# option multiple times (only on the command line, not in the configuration
-# file where it should appear only once).You can also use "--disable=all" to
-# disable everything first and then reenable specific checks. For example, if
-# you want to run only the similarities checker, you can use "--disable=all
-# --enable=similarities". If you want to run only the classes checker, but have
-# no Warning level messages displayed, use"--disable=all --enable=classes
-# --disable=W"
-disable=bad-inline-option,
-        deprecated-pragma,
-        django-not-configured,
-        file-ignored,
-        locally-disabled,
-        no-self-use,
-        raw-checker-failed,
-        suppressed-message,
-        useless-suppression
-
-# Enable the message, report, category or checker with the given id(s). You can
-# either give multiple identifier separated by comma (,) or put this option
-# multiple time (only on the command line, not in the configuration file where
-# it should appear only once). See also the "--disable" option for examples.
-enable=c-extension-no-member
-
-
-[REPORTS]
-
-# Python expression which should return a note less than 10 (10 is the highest
-# note). You have access to the variables errors warning, statement which
-# respectively contain the number of errors / warnings messages and the total
-# number of statements analyzed. This is used by the global evaluation report
-# (RP0004).
-evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
-
-# Template used to display messages. This is a python new-style format string
-# used to format the message information. See doc for all details
-#msg-template=
-
-# Set the output format. Available formats are text, parseable, colorized, json
-# and msvs (visual studio).You can also give a reporter class, eg
-# mypackage.mymodule.MyReporterClass.
-output-format=text
-
-# Tells whether to display a full report or only the messages
-reports=no
-
-# Activate the evaluation score.
-score=yes
-
-
-[REFACTORING]
-
-# Maximum number of nested blocks for function / method body
-max-nested-blocks=5
-
-# Complete name of functions that never returns. When checking for
-# inconsistent-return-statements if a never returning function is called then
-# it will be considered as an explicit return statement and no message will be
-# printed.
-never-returning-functions=optparse.Values,sys.exit
-
-
-[LOGGING]
-
-# Logging modules to check that the string format arguments are in logging
-# function parameter format
-logging-modules=logging
-
-
-[SPELLING]
-
-# Limits count of emitted suggestions for spelling mistakes
-max-spelling-suggestions=4
-
-# Spelling dictionary name. Available dictionaries: none. To make it working
-# install python-enchant package.
-spelling-dict=
-
-# List of comma separated words that should not be checked.
-spelling-ignore-words=
-
-# A path to a file that contains private dictionary; one word per line.
-spelling-private-dict-file=
-
-# Tells whether to store unknown words to indicated private dictionary in
-# --spelling-private-dict-file option instead of raising a message.
-spelling-store-unknown-words=no
-
-
-[MISCELLANEOUS]
-
-# List of note tags to take in consideration, separated by a comma.
-notes=FIXME,
-      XXX,
-      TODO
-
-
-[TYPECHECK]
-
-# List of decorators that produce context managers, such as
-# contextlib.contextmanager. Add to this list to register other decorators that
-# produce valid context managers.
-contextmanager-decorators=contextlib.contextmanager
-
-# List of members which are set dynamically and missed by pylint inference
-# system, and so shouldn't trigger E1101 when accessed. Python regular
-# expressions are accepted.
-generated-members=
-
-# Tells whether missing members accessed in mixin class should be ignored. A
-# mixin class is detected if its name ends with "mixin" (case insensitive).
-ignore-mixin-members=yes
-
-# This flag controls whether pylint should warn about no-member and similar
-# checks whenever an opaque object is returned when inferring. The inference
-# can return multiple potential results while evaluating a Python object, but
-# some branches might not be evaluated, which results in partial inference. In
-# that case, it might be useful to still emit no-member and other checks for
-# the rest of the inferred objects.
-ignore-on-opaque-inference=yes
-
-# List of class names for which member attributes should not be checked (useful
-# for classes with dynamically set attributes). This supports the use of
-# qualified names.
-ignored-classes=optparse.Values,thread._local,_thread._local,responses,
-                Template,Contact
-
-# List of module names for which member attributes should not be checked
-# (useful for modules/projects where namespaces are manipulated during runtime
-# and thus existing member attributes cannot be deduced by static analysis. It
-# supports qualified module names, as well as Unix pattern matching.
-ignored-modules=
-
-# Show a hint with possible names when a member name was not found. The aspect
-# of finding the hint is based on edit distance.
-missing-member-hint=yes
-
-# The minimum edit distance a name should have in order to be considered a
-# similar match for a missing member name.
-missing-member-hint-distance=1
-
-# The total number of similar names that should be taken in consideration when
-# showing a hint for a missing member.
-missing-member-max-choices=1
-
-
-[VARIABLES]
-
-# List of additional names supposed to be defined in builtins. Remember that
-# you should avoid to define new builtins when possible.
-additional-builtins=
-
-# Tells whether unused global variables should be treated as a violation.
-allow-global-unused-variables=yes
-
-# List of strings which can identify a callback function by name. A callback
-# name must start or end with one of those strings.
-callbacks=cb_,
-          _cb
-
-# A regular expression matching the name of dummy variables (i.e. expectedly
-# not used).
-dummy-variables-rgx=_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_
-
-# Argument names that match this expression will be ignored. Default to name
-# with leading underscore
-ignored-argument-names=_.*|^ignored_|^unused_
-
-# Tells whether we should check for unused import in __init__ files.
-init-import=no
-
-# List of qualified module names which can have objects that can redefine
-# builtins.
-redefining-builtins-modules=six.moves,past.builtins,future.builtins
-
-
-[FORMAT]
-
-# Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
-expected-line-ending-format=
-
-# Regexp for a line that is allowed to be longer than the limit.
-ignore-long-lines=^\s*(# )?<?https?://\S+>?$
-
-# Number of spaces of indent required inside a hanging  or continued line.
-indent-after-paren=4
-
-# String used as indentation unit. This is usually "    " (4 spaces) or "\t" (1
-# tab).
-indent-string='    '
-
-# Maximum number of characters on a single line.
-max-line-length=100
-
-# Maximum number of lines in a module
-max-module-lines=1000
-
-# Allow the body of a class to be on the same line as the declaration if body
-# contains single statement.
-single-line-class-stmt=no
-
-# Allow the body of an if to be on the same line as the test if there is no
-# else.
-single-line-if-stmt=no
-
-
-[SIMILARITIES]
-
-# Ignore comments when computing similarities.
-ignore-comments=yes
-
-# Ignore docstrings when computing similarities.
-ignore-docstrings=yes
-
-# Ignore imports when computing similarities.
-ignore-imports=yes
-
-# Minimum lines number of a similarity.
-# First implementations of CMS wizards have common fields we do not want to factorize for now
-min-similarity-lines=35
-
-
-[BASIC]
-
-# Naming style matching correct argument names
-argument-naming-style=snake_case
-
-# Regular expression matching correct argument names. Overrides argument-
-# naming-style
-#argument-rgx=
-
-# Naming style matching correct attribute names
-attr-naming-style=snake_case
-
-# Regular expression matching correct attribute names. Overrides attr-naming-
-# style
-#attr-rgx=
-
-# Bad variable names which should always be refused, separated by a comma
-bad-names=foo,
-          bar,
-          baz,
-          toto,
-          tutu,
-          tata
-
-# Naming style matching correct class attribute names
-class-attribute-naming-style=any
-
-# Regular expression matching correct class attribute names. Overrides class-
-# attribute-naming-style
-#class-attribute-rgx=
-
-# Naming style matching correct class names
-class-naming-style=PascalCase
-
-# Regular expression matching correct class names. Overrides class-naming-style
-#class-rgx=
-
-# Naming style matching correct constant names
-const-naming-style=UPPER_CASE
-
-# Regular expression matching correct constant names. Overrides const-naming-
-# style
-const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__)|urlpatterns|logger)$
-
-# Minimum line length for functions/classes that require docstrings, shorter
-# ones are exempt.
-docstring-min-length=-1
-
-# Naming style matching correct function names
-function-naming-style=snake_case
-
-# Regular expression matching correct function names. Overrides function-
-# naming-style
-#function-rgx=
-
-# Good variable names which should always be accepted, separated by a comma
-good-names=i,
-           j,
-           k,
-           cm,
-           ex,
-           Run,
-           _
-
-# Include a hint for the correct naming format with invalid-name
-include-naming-hint=no
-
-# Naming style matching correct inline iteration names
-inlinevar-naming-style=any
-
-# Regular expression matching correct inline iteration names. Overrides
-# inlinevar-naming-style
-#inlinevar-rgx=
-
-# Naming style matching correct method names
-method-naming-style=snake_case
-
-# Regular expression matching correct method names. Overrides method-naming-
-# style
-method-rgx=([a-z_][a-z0-9_]{2,50}|setUp|set[Uu]pClass|tearDown|tear[Dd]ownClass|assert[A-Z]\w*|maxDiff|test_[a-z0-9_]+)$
-
-# Naming style matching correct module names
-module-naming-style=snake_case
-
-# Regular expression matching correct module names. Overrides module-naming-
-# style
-#module-rgx=
-
-# Colon-delimited sets of names that determine each other's naming style when
-# the name regexes allow several styles.
-name-group=
-
-# Regular expression which should only match function or class names that do
-# not require a docstring.
-no-docstring-rgx=^_
-
-# List of decorators that produce properties, such as abc.abstractproperty. Add
-# to this list to register other decorators that produce valid properties.
-property-classes=abc.abstractproperty
-
-# Naming style matching correct variable names
-variable-naming-style=snake_case
-
-# Regular expression matching correct variable names. Overrides variable-
-# naming-style
-#variable-rgx=
-
-
-[IMPORTS]
-
-# Allow wildcard imports from modules that define __all__.
-allow-wildcard-with-all=no
-
-# Analyse import fallback blocks. This can be used to support both Python 2 and
-# 3 compatible code, which means that the block might have code that exists
-# only in one or another interpreter, leading to false positives when analysed.
-analyse-fallback-blocks=no
-
-# Deprecated modules which should not be used, separated by a comma
-deprecated-modules=optparse,tkinter.tix
-
-# Create a graph of external dependencies in the given file (report RP0402 must
-# not be disabled)
-ext-import-graph=
-
-# Create a graph of every (i.e. internal and external) dependencies in the
-# given file (report RP0402 must not be disabled)
-import-graph=
-
-# Create a graph of internal dependencies in the given file (report RP0402 must
-# not be disabled)
-int-import-graph=
-
-# Force import order to recognize a module as part of the standard
-# compatibility libraries.
-known-standard-library=
-
-# Force import order to recognize a module as part of a third party library.
-known-third-party=enchant
-
-
-[CLASSES]
-
-# List of method names used to declare (i.e. assign) instance attributes.
-defining-attr-methods=__init__,
-                      __new__,
-                      setUp
-
-# List of member names, which should be excluded from the protected access
-# warning.
-exclude-protected=_asdict,
-                  _fields,
-                  _replace,
-                  _source,
-                  _make
-
-# List of valid names for the first argument in a class method.
-valid-classmethod-first-arg=cls
-
-# List of valid names for the first argument in a metaclass class method.
-valid-metaclass-classmethod-first-arg=mcs
-
-
-[DESIGN]
-
-# Maximum number of arguments for function / method
-max-args=5
-
-# Maximum number of attributes for a class (see R0902).
-max-attributes=7
-
-# Maximum number of boolean expressions in a if statement
-max-bool-expr=5
-
-# Maximum number of branch for function / method body
-max-branches=12
-
-# Maximum number of locals for function / method body
-max-locals=20
-
-# Maximum number of parents for a class (see R0901).
-max-parents=10
-
-# Maximum number of public methods for a class (see R0904).
-max-public-methods=20
-
-# Maximum number of return / yield for function / method body
-max-returns=6
-
-# Maximum number of statements in function / method body
-max-statements=50
-
-# Minimum number of public methods for a class (see R0903).
-min-public-methods=0
-
-
-[EXCEPTIONS]
-
-# Exceptions that will emit a warning when being caught. Defaults to
-# "Exception"
-overgeneral-exceptions=builtins.Exception

src/backend/MANIFEST.in

@@ -1,3 +0,0 @@
-include LICENSE
-include README.md
-recursive-include src/backend/meet *.html *.png *.gif *.css *.ico *.jpg *.jpeg *.po *.mo *.eot *.svg *.ttf *.woff *.woff2

src/backend/core/admin.py

@@ -1,123 +0,0 @@
-"""Admin classes and registrations for core app."""
-
-from django.contrib import admin
-from django.contrib.auth import admin as auth_admin
-from django.utils.translation import gettext_lazy as _
-
-from . import models
-
-
-@admin.register(models.User)
-class UserAdmin(auth_admin.UserAdmin):
-    """Admin class for the User model"""
-
-    fieldsets = (
-        (
-            None,
-            {
-                "fields": (
-                    "id",
-                    "admin_email",
-                    "password",
-                )
-            },
-        ),
-        (
-            _("Personal info"),
-            {
-                "fields": (
-                    "sub",
-                    "email",
-                    "full_name",
-                    "short_name",
-                    "language",
-                    "timezone",
-                )
-            },
-        ),
-        (
-            _("Permissions"),
-            {
-                "fields": (
-                    "is_active",
-                    "is_device",
-                    "is_staff",
-                    "is_superuser",
-                    "groups",
-                    "user_permissions",
-                ),
-            },
-        ),
-        (_("Important dates"), {"fields": ("created_at", "updated_at")}),
-    )
-    add_fieldsets = (
-        (
-            None,
-            {
-                "classes": ("wide",),
-                "fields": ("email", "password1", "password2"),
-            },
-        ),
-    )
-    list_display = (
-        "id",
-        "sub",
-        "admin_email",
-        "email",
-        "full_name",
-        "short_name",
-        "is_active",
-        "is_staff",
-        "is_superuser",
-        "is_device",
-        "created_at",
-        "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")
-
-
-class ResourceAccessInline(admin.TabularInline):
-    """Admin class for the room user access model"""
-
-    model = models.ResourceAccess
-    extra = 0
-
-
-@admin.register(models.Room)
-class RoomAdmin(admin.ModelAdmin):
-    """Room admin interface declaration."""
-
-    inlines = (ResourceAccessInline,)
-
-
-class RecordingAccessInline(admin.TabularInline):
-    """Inline admin class for recording accesses."""
-
-    model = models.RecordingAccess
-    extra = 0
-
-
-@admin.register(models.Recording)
-class RecordingAdmin(admin.ModelAdmin):
-    """Recording admin interface declaration."""
-
-    inlines = (RecordingAccessInline,)
-    list_display = ("id", "status", "room", "created_at", "worker_id")

src/backend/core/api/__init__.py

@@ -1,46 +0,0 @@
-"""Meet core API endpoints"""
-
-from django.conf import settings
-from django.core.exceptions import ValidationError
-
-from rest_framework import exceptions as drf_exceptions
-from rest_framework import views as drf_views
-from rest_framework.decorators import api_view
-from rest_framework.response import Response
-
-
-def exception_handler(exc, context):
-    """Handle Django ValidationError as an accepted exception.
-
-    For the parameters, see ``exception_handler``
-    This code comes from twidi's gist:
-    https://gist.github.com/twidi/9d55486c36b6a51bdcb05ce3a763e79f
-    """
-    if isinstance(exc, ValidationError):
-        if hasattr(exc, "message_dict"):
-            detail = exc.message_dict
-        elif hasattr(exc, "message"):
-            detail = exc.message
-        elif hasattr(exc, "messages"):
-            detail = exc.messages
-        else:
-            detail = ""
-
-        exc = drf_exceptions.ValidationError(detail=detail)
-
-    return drf_views.exception_handler(exc, context)
-
-
-# pylint: disable=unused-argument
-@api_view(["GET"])
-def get_frontend_configuration(request):
-    """Returns the frontend configuration dict as configured in settings."""
-    frontend_configuration = {
-        "LANGUAGE_CODE": settings.LANGUAGE_CODE,
-        "recording": {
-            "is_enabled": settings.RECORDING_ENABLE,
-            "available_modes": settings.RECORDING_WORKER_CLASSES.keys(),
-        },
-    }
-    frontend_configuration.update(settings.FRONTEND_CONFIGURATION)
-    return Response(frontend_configuration)

src/backend/core/api/permissions.py

@@ -1,121 +0,0 @@
-"""Permission handlers for the Meet core app."""
-
-from django.conf import settings
-
-from rest_framework import permissions
-
-from ..models import RoleChoices
-
-ACTION_FOR_METHOD_TO_PERMISSION = {
-    "versions_detail": {"DELETE": "versions_destroy", "GET": "versions_retrieve"}
-}
-
-
-class IsAuthenticated(permissions.BasePermission):
-    """
-    Allows access only to authenticated users. Alternative method checking the presence
-    of the auth token to avoid hitting the database.
-    """
-
-    def has_permission(self, request, view):
-        return bool(request.auth) or request.user.is_authenticated
-
-
-class IsAuthenticatedOrSafe(IsAuthenticated):
-    """Allows access to authenticated users (or anonymous users but only on safe methods)."""
-
-    def has_permission(self, request, view):
-        if request.method in permissions.SAFE_METHODS:
-            return True
-        return super().has_permission(request, view)
-
-
-class IsSelf(IsAuthenticated):
-    """
-    Allows access only to authenticated users. Alternative method checking the presence
-    of the auth token to avoid hitting the database.
-    """
-
-    def has_object_permission(self, request, view, obj):
-        """Write permissions are only allowed to the user itself."""
-        return obj == request.user
-
-
-class RoomPermissions(permissions.BasePermission):
-    """
-    Permissions applying to the room API endpoint.
-    """
-
-    def has_permission(self, request, view):
-        """Only allow authenticated users for unsafe methods."""
-        if request.method in permissions.SAFE_METHODS:
-            return True
-
-        return request.user.is_authenticated
-
-    def has_object_permission(self, request, view, obj):
-        """Object permissions are only given to administrators of the room."""
-
-        if request.method in permissions.SAFE_METHODS:
-            return True
-
-        user = request.user
-
-        if request.method == "DELETE":
-            return obj.is_owner(user)
-
-        return obj.is_administrator(user)
-
-
-class ResourceAccessPermission(IsAuthenticated):
-    """
-    Permissions for a room that can only be updated by room administrators.
-    """
-
-    def has_object_permission(self, request, view, obj):
-        """
-        Check that the logged-in user is administrator of the linked room.
-        """
-        user = request.user
-        if request.method == "DELETE" and obj.role == RoleChoices.OWNER:
-            return obj.user == user
-
-        return obj.resource.is_administrator(user)
-
-
-class HasAbilityPermission(IsAuthenticated):
-    """Permission class for access objects."""
-
-    def has_object_permission(self, request, view, obj):
-        """Check permission for a given object."""
-        return obj.get_abilities(request.user).get(view.action, False)
-
-
-class HasPrivilegesOnRoom(IsAuthenticated):
-    """Check if user has privileges on a given room."""
-
-    message = "You must have privileges to start a recording."
-
-    def has_object_permission(self, request, view, obj):
-        """Determine if user has privileges on room."""
-        return obj.is_owner(request.user) or obj.is_administrator(request.user)
-
-
-class IsRecordingEnabled(permissions.BasePermission):
-    """Check if the recording feature is enabled."""
-
-    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

src/backend/core/api/serializers.py

@@ -1,180 +0,0 @@
-"""Client serializers for the Meet core app."""
-
-from django.conf import settings
-from django.utils.translation import gettext_lazy as _
-
-from rest_framework import serializers
-from rest_framework.exceptions import PermissionDenied
-
-from core import models, utils
-
-
-class UserSerializer(serializers.ModelSerializer):
-    """Serialize users."""
-
-    class Meta:
-        model = models.User
-        fields = ["id", "email", "full_name", "short_name"]
-        read_only_fields = ["id", "email", "full_name", "short_name"]
-
-
-class ResourceAccessSerializerMixin:
-    """
-    A serializer mixin to share controlling that the logged-in user submitting a room access object
-    is administrator on the targeted room.
-    """
-
-    # pylint: disable=too-many-boolean-expressions
-    def validate(self, data):
-        """
-        Check access rights specific to writing (create/update)
-        """
-        request = self.context.get("request", None)
-        user = getattr(request, "user", None)
-        if (
-            # Update
-            self.instance
-            and (
-                data["role"] == models.RoleChoices.OWNER
-                and not self.instance.resource.is_owner(user)
-                or self.instance.role == models.RoleChoices.OWNER
-                and not self.instance.user == user
-            )
-        ) or (
-            # Create
-            not self.instance
-            and data.get("role") == models.RoleChoices.OWNER
-            and not data["resource"].is_owner(user)
-        ):
-            raise PermissionDenied(
-                "Only owners of a room can assign other users as owners."
-            )
-        return data
-
-    def validate_resource(self, resource):
-        """The logged-in user must be administrator of the resource."""
-        request = self.context.get("request", None)
-        user = getattr(request, "user", None)
-
-        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.")
-            )
-
-        return resource
-
-
-class ResourceAccessSerializer(
-    ResourceAccessSerializerMixin, serializers.ModelSerializer
-):
-    """Serialize Room to User accesses for the API."""
-
-    class Meta:
-        model = models.ResourceAccess
-        fields = ["id", "user", "resource", "role"]
-        read_only_fields = ["id"]
-
-    def update(self, instance, validated_data):
-        """Make "user" and "resource" fields readonly but only on update."""
-        validated_data.pop("resource", None)
-        validated_data.pop("user", None)
-        return super().update(instance, validated_data)
-
-
-class NestedResourceAccessSerializer(ResourceAccessSerializer):
-    """Serialize Room accesses for the API with full nested user."""
-
-    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", "is_public"]
-        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", "is_public"]
-        read_only_fields = ["id", "slug"]
-
-    def to_representation(self, instance):
-        """
-        Add users only for administrator users.
-        Add LiveKit credentials for public instance or related users/groups
-        """
-        output = super().to_representation(instance)
-        request = self.context.get("request")
-
-        if not request:
-            return output
-
-        role = instance.get_role(request.user)
-        is_admin = models.RoleChoices.check_administrator_role(role)
-
-        if role is not None:
-            access_serializer = NestedResourceAccessSerializer(
-                instance.accesses.select_related("resource", "user").all(),
-                context=self.context,
-                many=True,
-            )
-            output["accesses"] = access_serializer.data
-
-        if not is_admin:
-            del output["configuration"]
-
-        if role is not None or instance.is_public:
-            room_id = f"{instance.id!s}"
-            username = request.query_params.get("username", None)
-
-            output["livekit"] = {
-                "url": settings.LIVEKIT_CONFIGURATION["url"],
-                "room": room_id,
-                "token": utils.generate_token(
-                    room=room_id, user=request.user, username=username
-                ),
-                "passphrase": utils.get_cached_passphrase(room_id)
-            }
-            
-        output["is_administrable"] = is_admin
-
-        return output
-
-
-class RecordingSerializer(serializers.ModelSerializer):
-    """Serialize Recording for the API."""
-
-    room = ListRoomSerializer(read_only=True)
-
-    class Meta:
-        model = models.Recording
-        fields = ["id", "room", "created_at", "updated_at", "status"]
-        read_only_fields = fields
-
-
-class StartRecordingSerializer(serializers.Serializer):
-    """Validate start recording requests."""
-
-    mode = serializers.ChoiceField(
-        choices=models.RecordingModeChoices.choices,
-        required=True,
-        error_messages={
-            "required": "Recording mode is required.",
-            "invalid_choice": "Invalid recording mode. Choose between "
-            "screen_recording or transcript.",
-        },
-    )
-
-    def create(self, validated_data):
-        """Not implemented as this is a validation-only serializer."""
-        raise NotImplementedError("StartRecordingSerializer is validation-only")
-
-    def update(self, instance, validated_data):
-        """Not implemented as this is a validation-only serializer."""
-        raise NotImplementedError("StartRecordingSerializer is validation-only")

src/backend/core/api/viewsets.py

@@ -1,503 +0,0 @@
-"""API endpoints"""
-
-import uuid
-from logging import getLogger
-
-from django.conf import settings
-from django.db.models import Q
-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,
-    viewsets,
-)
-from rest_framework import (
-    exceptions as drf_exceptions,
-)
-from rest_framework import (
-    response as drf_response,
-)
-from rest_framework import (
-    status as drf_status,
-)
-
-from core import models, utils
-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 . import permissions, serializers
-
-from livekit import api as livekit_api
-
-# pylint: disable=too-many-ancestors
-
-logger = getLogger(__name__)
-
-
-class NestedGenericViewSet(viewsets.GenericViewSet):
-    """
-    A generic Viewset aims to be used in a nested route context.
-    e.g: `/api/v1.0/resource_1/<resource_1_pk>/resource_2/<resource_2_pk>/`
-
-    It allows to define all url kwargs and lookup fields to perform the lookup.
-    """
-
-    lookup_fields: list[str] = ["pk"]
-    lookup_url_kwargs: list[str] = []
-
-    def __getattribute__(self, item):
-        """
-        This method is overridden to allow to get the last lookup field or lookup url kwarg
-        when accessing the `lookup_field` or `lookup_url_kwarg` attribute. This is useful
-        to keep compatibility with all methods used by the parent class `GenericViewSet`.
-        """
-        if item in ["lookup_field", "lookup_url_kwarg"]:
-            return getattr(self, item + "s", [None])[-1]
-
-        return super().__getattribute__(item)
-
-    def get_queryset(self):
-        """
-        Get the list of items for this view.
-
-        `lookup_fields` attribute is enumerated here to perform the nested lookup.
-        """
-        queryset = super().get_queryset()
-
-        # The last lookup field is removed to perform the nested lookup as it corresponds
-        # to the object pk, it is used within get_object method.
-        lookup_url_kwargs = (
-            self.lookup_url_kwargs[:-1]
-            if self.lookup_url_kwargs
-            else self.lookup_fields[:-1]
-        )
-
-        filter_kwargs = {}
-        for index, lookup_url_kwarg in enumerate(lookup_url_kwargs):
-            if lookup_url_kwarg not in self.kwargs:
-                raise KeyError(
-                    f"Expected view {self.__class__.__name__} to be called with a URL "
-                    f'keyword argument named "{lookup_url_kwarg}". Fix your URL conf, or '
-                    "set the `.lookup_fields` attribute on the view correctly."
-                )
-
-            filter_kwargs.update(
-                {self.lookup_fields[index]: self.kwargs[lookup_url_kwarg]}
-            )
-
-        return queryset.filter(**filter_kwargs)
-
-
-class SerializerPerActionMixin:
-    """
-    A mixin to allow to define serializer classes for each action.
-
-    This mixin is useful to avoid to define a serializer class for each action in the
-    `get_serializer_class` method.
-    """
-
-    serializer_classes: dict[str, type] = {}
-    default_serializer_class: type = None
-
-    def get_serializer_class(self):
-        """
-        Return the serializer class to use depending on the action.
-        """
-        return self.serializer_classes.get(self.action, self.default_serializer_class)
-
-
-class Pagination(pagination.PageNumberPagination):
-    """Pagination to display no more than 100 objects per page sorted by creation date."""
-
-    ordering = "-created_on"
-    max_page_size = 100
-    page_size_query_param = "page_size"
-
-
-class UserViewSet(
-    mixins.UpdateModelMixin, viewsets.GenericViewSet, mixins.ListModelMixin
-):
-    """User ViewSet"""
-
-    permission_classes = [permissions.IsSelf]
-    queryset = models.User.objects.all()
-    serializer_class = serializers.UserSerializer
-
-    def get_queryset(self):
-        """
-        Limit listed users by querying the email field with a trigram similarity
-        search if a query is provided.
-        Limit listed users by excluding users already in the document if a document_id
-        is provided.
-        """
-        queryset = self.queryset
-
-        if self.action == "list":
-            # 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", ""):
-                queryset = queryset.filter(email__trigram_word_similar=query)
-
-        return queryset
-
-    @decorators.action(
-        detail=False,
-        methods=["get"],
-        url_name="me",
-        url_path="me",
-        permission_classes=[permissions.IsAuthenticated],
-    )
-    def get_me(self, request):
-        """
-        Return information on currently logged user
-        """
-        context = {"request": request}
-        return drf_response.Response(
-            self.serializer_class(request.user, context=context).data
-        )
-
-
-class RoomViewSet(
-    mixins.CreateModelMixin,
-    mixins.DestroyModelMixin,
-    mixins.UpdateModelMixin,
-    viewsets.GenericViewSet,
-):
-    """
-    API endpoints to access and perform actions on rooms.
-    """
-
-    permission_classes = [permissions.RoomPermissions]
-    queryset = models.Room.objects.all()
-    serializer_class = serializers.RoomSerializer
-
-    def get_object(self):
-        """Allow getting a room by its slug."""
-        try:
-            uuid.UUID(self.kwargs["pk"])
-            filter_kwargs = {"pk": self.kwargs["pk"]}
-        except ValueError:
-            filter_kwargs = {"slug": slugify(self.kwargs["pk"])}
-        queryset = self.filter_queryset(self.get_queryset())
-        obj = get_object_or_404(queryset, **filter_kwargs)
-        # May raise a permission denied
-        self.check_object_permissions(self.request, obj)
-        return obj
-
-    def retrieve(self, request, *args, **kwargs):
-        """
-        Allow unregistered rooms when activated.
-        For unregistered rooms we only return a null id and the livekit room and token.
-        """
-
-        # todo - determine whether encryption is needed store a shared secret in memory or in redis
-        # todo - check if a secret already exists, else create one.
-
-        try:
-            instance = self.get_object()
-        except Http404:
-            if not settings.ALLOW_UNREGISTERED_ROOMS:
-                raise
-            slug = slugify(self.kwargs["pk"])
-            username = request.query_params.get("username", None)
-            data = {
-                "id": None,
-                "livekit": {
-                    "url": settings.LIVEKIT_CONFIGURATION["url"],
-                    "room": slug,
-                    "token": utils.generate_token(
-                        room=slug, user=request.user, username=username
-                    ),
-                },
-            }
-        else:
-            data = self.get_serializer(instance).data
-
-        return drf_response.Response(data)
-
-    def list(self, request, *args, **kwargs):
-        """Limit listed rooms to the ones related to the authenticated user."""
-        user = self.request.user
-
-        if user.is_authenticated:
-            queryset = (
-                self.filter_queryset(self.get_queryset()).filter(users=user).distinct()
-            )
-        else:
-            queryset = self.get_queryset().none()
-
-        page = self.paginate_queryset(queryset)
-        if page is not None:
-            serializer = self.get_serializer(page, many=True)
-            return self.get_paginated_response(serializer.data)
-
-        serializer = self.get_serializer(queryset, many=True)
-        return drf_response.Response(serializer.data)
-
-    def perform_create(self, serializer):
-        """Set the current user as owner of the newly created room."""
-        room = serializer.save()
-        models.ResourceAccess.objects.create(
-            resource=room,
-            user=self.request.user,
-            role=models.RoleChoices.OWNER,
-        )
-
-    @decorators.action(
-        detail=True,
-        methods=["post"],
-        url_path="start-recording",
-        permission_classes=[
-            permissions.HasPrivilegesOnRoom,
-            permissions.IsRecordingEnabled,
-        ],
-    )
-    def start_room_recording(self, request, pk=None):  # pylint: disable=unused-argument
-        """Start recording a room."""
-
-        serializer = serializers.StartRecordingSerializer(data=request.data)
-
-        if not serializer.is_valid():
-            return drf_response.Response(
-                {"detail": "Invalid request."}, status=drf_status.HTTP_400_BAD_REQUEST
-            )
-
-        mode = serializer.validated_data["mode"]
-        room = self.get_object()
-
-        # May raise exception if an active or initiated recording already exist for the room
-        recording = models.Recording.objects.create(room=room, mode=mode)
-
-        models.RecordingAccess.objects.create(
-            user=self.request.user, role=models.RoleChoices.OWNER, recording=recording
-        )
-
-        worker_service = get_worker_service(mode=recording.mode)
-        worker_manager = WorkerServiceMediator(worker_service=worker_service)
-
-        try:
-            worker_manager.start(recording)
-        except RecordingStartError:
-            return drf_response.Response(
-                {"error": f"Recording failed to start for room {room.slug}"},
-                status=drf_status.HTTP_500_INTERNAL_SERVER_ERROR,
-            )
-
-        return drf_response.Response(
-            {"message": f"Recording successfully started for room {room.slug}"},
-            status=drf_status.HTTP_201_CREATED,
-        )
-
-    @decorators.action(
-        detail=True,
-        methods=["post"],
-        url_path="stop-recording",
-        permission_classes=[
-            permissions.HasPrivilegesOnRoom,
-            permissions.IsRecordingEnabled,
-        ],
-    )
-    def stop_room_recording(self, request, pk=None):  # pylint: disable=unused-argument
-        """Stop room recording."""
-
-        room = self.get_object()
-
-        try:
-            recording = models.Recording.objects.get(
-                room=room, status=models.RecordingStatusChoices.ACTIVE
-            )
-        except models.Recording.DoesNotExist as e:
-            raise drf_exceptions.NotFound(
-                "No active recording found for this room."
-            ) from e
-
-        worker_service = get_worker_service(mode=recording.mode)
-        worker_manager = WorkerServiceMediator(worker_service=worker_service)
-
-        try:
-            worker_manager.stop(recording)
-        except RecordingStopError:
-            return drf_response.Response(
-                {"error": f"Recording failed to stop for room {room.slug}"},
-                status=drf_status.HTTP_500_INTERNAL_SERVER_ERROR,
-            )
-
-        return drf_response.Response(
-            {"message": f"Recording stopped for room {room.slug}."}
-        )
-
-    @decorators.action(
-        detail=False,
-        methods=["post"],
-        url_path="livekit-webhook",
-        permission_classes=[],
-        authentication_classes=[],
-    )
-    def handle_livekit_webhook(self, request, pk=None):  # pylint: disable=unused-argument
-        """Handle LiveKit webhook events."""
-        auth_token = request.headers.get("Authorization")
-        if not auth_token:
-            return drf_response.Response(
-                {"error": "Missing LiveKit authentication token"},
-                status=drf_status.HTTP_401_UNAUTHORIZED
-            )
-
-        token_verifier = livekit_api.TokenVerifier()
-        webhook_receiver = livekit_api.WebhookReceiver(token_verifier)
-
-        webhook_data = webhook_receiver.receive(request.body.decode("utf-8"), auth_token)
-
-        # Todo - livekit triggers a webhook for all events, see if we can restrict webhook to a limited number of events.
-        # Todo - handle Egress stopped / aborted events.
-
-        if webhook_data.event == "room_finished":
-            room_id = webhook_data.room.name
-            utils.clear_cache_passphrase(room_id)
-
-        return drf_response.Response({"message": f"Event processed"})
-
-
-class ResourceAccessListModelMixin:
-    """List mixin for resource access API."""
-
-    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()
-        if self.action == "list":
-            user = self.request.user
-            queryset = queryset.filter(
-                Q(resource__accesses__user=user),
-                resource__accesses__role__in=[
-                    models.RoleChoices.ADMIN,
-                    models.RoleChoices.OWNER,
-                ],
-            ).distinct()
-        return queryset
-
-
-class ResourceAccessViewSet(
-    ResourceAccessListModelMixin,
-    mixins.CreateModelMixin,
-    mixins.DestroyModelMixin,
-    mixins.ListModelMixin,
-    mixins.RetrieveModelMixin,
-    mixins.UpdateModelMixin,
-    viewsets.GenericViewSet,
-):
-    """
-    API endpoints to access and perform actions on resource accesses.
-    """
-
-    permission_classes = [permissions.ResourceAccessPermission]
-    queryset = models.ResourceAccess.objects.all()
-    serializer_class = serializers.ResourceAccessSerializer
-
-
-class RecordingViewSet(
-    mixins.DestroyModelMixin,
-    mixins.ListModelMixin,
-    viewsets.GenericViewSet,
-):
-    """
-    API endpoints to access and perform actions on recordings.
-    """
-
-    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."},
-        )

src/backend/core/apps.py

@@ -1,11 +0,0 @@
-"""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,171 +0,0 @@
-"""Authentication Backends for the Meet core app."""
-
-from django.conf import settings
-from django.core.exceptions import ImproperlyConfigured, SuspiciousOperation
-from django.utils.translation import gettext_lazy as _
-
-import requests
-from mozilla_django_oidc.auth import (
-    OIDCAuthenticationBackend as MozillaOIDCAuthenticationBackend,
-)
-
-from core.models import User
-from core.services.marketing_service import (
-    ContactCreationError,
-    ContactData,
-    get_marketing_service,
-)
-
-
-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_userinfo(self, access_token, id_token, payload):
-        """Return user details 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: User details dictionary obtained from the OpenID Connect user endpoint.
-        """
-
-        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
-
-    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:
-        - User: An existing or newly created User instance.
-
-        Raises:
-        - Exception: Raised when user creation is not allowed and no existing user is found.
-        """
-
-        user_info = self.get_userinfo(access_token, id_token, payload)
-        sub = user_info.get("sub")
-
-        if not sub:
-            raise SuspiciousOperation(
-                _("User info contained no recognizable user identification")
-            )
-
-        email = user_info.get("email")
-        user = self.get_existing_user(sub, email)
-
-        claims = {
-            "email": email,
-            "full_name": self.compute_full_name(user_info),
-            "short_name": user_info.get(settings.OIDC_USERINFO_SHORTNAME_FIELD),
-        }
-        if not user and self.get_settings("OIDC_CREATE_USER", True):
-            user = User.objects.create(
-                sub=sub,
-                password="!",  # noqa: S106
-                **claims,
-            )
-
-            if settings.SIGNUP_NEW_USER_TO_MARKETING_EMAIL:
-                self.signup_to_marketing_email(email)
-
-        elif not user:
-            return None
-
-        if not user.is_active:
-            raise SuspiciousOperation(_("User account is disabled"))
-
-        self.update_user_if_needed(user, claims)
-
-        return user
-
-    @staticmethod
-    def signup_to_marketing_email(email):
-        """Pragmatic approach to newsletter signup during authentication flow.
-
-        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)
-        """
-        try:
-            marketing_service = get_marketing_service()
-            contact_data = ContactData(
-                email=email, attributes={"VISIO_SOURCE": ["SIGNIN"]}
-            )
-            marketing_service.create_contact(contact_data, timeout=1)
-        except (ContactCreationError, ImproperlyConfigured, ImportError):
-            pass
-
-    def get_existing_user(self, sub, email):
-        """Fetch existing user by sub or email."""
-        try:
-            return User.objects.get(sub=sub)
-        except User.DoesNotExist:
-            if email and settings.OIDC_FALLBACK_TO_EMAIL_FOR_IDENTIFICATION:
-                try:
-                    return User.objects.get(email__iexact=email)
-                except User.DoesNotExist:
-                    pass
-                except User.MultipleObjectsReturned as e:
-                    raise SuspiciousOperation(
-                        _("Multiple user accounts share a common email.")
-                    ) from e
-        return None
-
-    @staticmethod
-    def compute_full_name(user_info):
-        """Compute user's full name based on OIDC fields in settings."""
-        full_name = " ".join(
-            filter(
-                None,
-                (
-                    user_info.get(field)
-                    for field in settings.OIDC_USERINFO_FULLNAME_FIELDS
-                ),
-            )
-        )
-        return full_name or None
-
-    @staticmethod
-    def update_user_if_needed(user, claims):
-        """Update user claims if they have changed."""
-        user_fields = vars(user.__class__)  # Get available model fields
-        updated_claims = {
-            key: value
-            for key, value in claims.items()
-            if value and key in user_fields and value != getattr(user, key)
-        }
-
-        if not updated_claims:
-            return
-
-        User.objects.filter(sub=user.sub).update(**updated_claims)

src/backend/core/authentication/urls.py

@@ -1,18 +0,0 @@
-"""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

@@ -1,181 +0,0 @@
-"""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,
-)
-
-
-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
-
-        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 login 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 login 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

@@ -1,16 +0,0 @@
-"""
-Core application enums declaration
-"""
-
-from django.conf import global_settings, settings
-from django.utils.translation import gettext_lazy as _
-
-# 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.
-# pylint: disable=no-member
-ALL_LANGUAGES = getattr(
-    settings,
-    "ALL_LANGUAGES",
-    [(language, _(name)) for language, name in global_settings.LANGUAGES],
-)

src/backend/core/factories.py

@@ -1,121 +0,0 @@
-# ruff: noqa: S311
-"""
-Core application factories
-"""
-
-from django.conf import settings
-from django.contrib.auth.hashers import make_password
-from django.utils.text import slugify
-
-import factory.fuzzy
-from faker import Faker
-
-from core import models
-
-fake = Faker()
-
-
-class UserFactory(factory.django.DjangoModelFactory):
-    """A factory to random users for testing purposes."""
-
-    class Meta:
-        model = models.User
-
-    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")
-
-
-class ResourceFactory(factory.django.DjangoModelFactory):
-    """Create fake resources for testing."""
-
-    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):
-        """Add users to resource from a given list of users."""
-        if create and extracted:
-            for item in extracted:
-                if isinstance(item, models.User):
-                    UserResourceAccessFactory(resource=self, user=item)
-                else:
-                    UserResourceAccessFactory(resource=self, user=item[0], role=item[1])
-
-        self.save()
-
-
-class UserResourceAccessFactory(factory.django.DjangoModelFactory):
-    """Create fake resource user accesses for testing."""
-
-    class Meta:
-        model = models.ResourceAccess
-
-    resource = factory.SubFactory(ResourceFactory)
-    user = factory.SubFactory(UserFactory)
-    role = factory.fuzzy.FuzzyChoice(models.RoleChoices.values)
-
-
-class RoomFactory(ResourceFactory):
-    """Create fake rooms for testing."""
-
-    class Meta:
-        model = models.Room
-
-    name = factory.Faker("catch_phrase")
-    slug = factory.LazyAttribute(lambda o: slugify(o.name))
-
-
-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/0001_initial.py

@@ -1,105 +0,0 @@
-# Generated by Django 5.0.3 on 2024-07-16 15:30
-
-import django.contrib.auth.models
-import django.core.validators
-import django.db.models.deletion
-import timezone_field.fields
-import uuid
-from django.conf import settings
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    initial = True
-
-    dependencies = [
-        ('auth', '0012_alter_user_first_name_max_length'),
-    ]
-
-    operations = [
-        migrations.CreateModel(
-            name='Resource',
-            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')),
-                ('is_public', models.BooleanField(default=True)),
-            ],
-            options={
-                'verbose_name': 'Resource',
-                'verbose_name_plural': 'Resources',
-                'db_table': 'meet_resource',
-            },
-        ),
-        migrations.CreateModel(
-            name='User',
-            fields=[
-                ('password', models.CharField(max_length=128, verbose_name='password')),
-                ('last_login', models.DateTimeField(blank=True, null=True, verbose_name='last login')),
-                ('is_superuser', models.BooleanField(default=False, help_text='Designates that this user has all permissions without explicitly assigning them.', verbose_name='superuser status')),
-                ('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')),
-                ('sub', models.CharField(blank=True, help_text='Required. 255 characters or fewer. Letters, numbers, and @/./+/-/_ characters only.', max_length=255, null=True, unique=True, validators=[django.core.validators.RegexValidator(message='Enter a valid sub. This value may contain only letters, numbers, and @/./+/-/_ characters.', regex='^[\\w.@+-]+\\Z')], verbose_name='sub')),
-                ('email', models.EmailField(blank=True, max_length=254, null=True, verbose_name='identity email address')),
-                ('admin_email', models.EmailField(blank=True, max_length=254, null=True, unique=True, verbose_name='admin email address')),
-                ('language', models.CharField(choices="(('en-us', 'English'), ('fr-fr', 'French'))", default='en-us', help_text='The language in which the user wants to see the interface.', max_length=10, verbose_name='language')),
-                ('timezone', timezone_field.fields.TimeZoneField(choices_display='WITH_GMT_OFFSET', default='UTC', help_text='The timezone in which the user wants to see times.', use_pytz=False)),
-                ('is_device', models.BooleanField(default=False, help_text='Whether the user is a device or a real user.', verbose_name='device')),
-                ('is_staff', models.BooleanField(default=False, help_text='Whether the user can log into this admin site.', verbose_name='staff status')),
-                ('is_active', models.BooleanField(default=True, help_text='Whether this user should be treated as active. Unselect this instead of deleting accounts.', verbose_name='active')),
-                ('groups', models.ManyToManyField(blank=True, help_text='The groups this user belongs to. A user will get all permissions granted to each of their groups.', related_name='user_set', related_query_name='user', to='auth.group', verbose_name='groups')),
-                ('user_permissions', models.ManyToManyField(blank=True, help_text='Specific permissions for this user.', related_name='user_set', related_query_name='user', to='auth.permission', verbose_name='user permissions')),
-            ],
-            options={
-                'verbose_name': 'user',
-                'verbose_name_plural': 'users',
-                'db_table': 'meet_user',
-            },
-            managers=[
-                ('objects', django.contrib.auth.models.UserManager()),
-            ],
-        ),
-        migrations.CreateModel(
-            name='Room',
-            fields=[
-                ('name', models.CharField(max_length=500)),
-                ('resource', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, parent_link=True, primary_key=True, serialize=False, to='core.resource')),
-                ('slug', models.SlugField(blank=True, max_length=100, null=True, unique=True)),
-                ('configuration', models.JSONField(blank=True, default={}, help_text='Values for Visio parameters to configure the room.', verbose_name='Visio room configuration')),
-            ],
-            options={
-                'verbose_name': 'Room',
-                'verbose_name_plural': 'Rooms',
-                'db_table': 'meet_room',
-                'ordering': ('name',),
-            },
-            bases=('core.resource',),
-        ),
-        migrations.CreateModel(
-            name='ResourceAccess',
-            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')),
-                ('role', models.CharField(choices=[('member', 'Member'), ('administrator', 'Administrator'), ('owner', 'Owner')], default='member', max_length=20)),
-                ('resource', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='accesses', to='core.resource')),
-                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='accesses', to=settings.AUTH_USER_MODEL)),
-            ],
-            options={
-                'verbose_name': 'Resource access',
-                'verbose_name_plural': 'Resource accesses',
-                'db_table': 'meet_resource_access',
-            },
-        ),
-        migrations.AddField(
-            model_name='resource',
-            name='users',
-            field=models.ManyToManyField(related_name='resources', through='core.ResourceAccess', to=settings.AUTH_USER_MODEL),
-        ),
-        migrations.AddConstraint(
-            model_name='resourceaccess',
-            constraint=models.UniqueConstraint(fields=('user', 'resource'), name='resource_access_unique_user_resource', violation_error_message='Resource access with this User and Resource already exists.'),
-        ),
-    ]

src/backend/core/migrations/0002_create_pg_trgm_extension.py

@@ -1,14 +0,0 @@
-from django.db import migrations
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('core', '0001_initial'),
-    ]
-
-    operations = [
-        migrations.RunSQL(
-            "CREATE EXTENSION IF NOT EXISTS pg_trgm;",
-            reverse_sql="DROP EXTENSION IF EXISTS pg_trgm;",
-        ),
-    ]

src/backend/core/migrations/0003_alter_room_configuration.py

@@ -1,18 +0,0 @@
-# Generated by Django 5.0.7 on 2024-08-07 14:38
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('core', '0002_create_pg_trgm_extension'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='room',
-            name='configuration',
-            field=models.JSONField(blank=True, default=dict, help_text='Values for Visio parameters to configure the room.', verbose_name='Visio room configuration'),
-        )
-    ]

src/backend/core/migrations/0004_alter_user_language.py

@@ -1,18 +0,0 @@
-# Generated by Django 5.0.7 on 2024-08-07 14:39
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('core', '0003_alter_room_configuration'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='user',
-            name='language',
-            field=models.CharField(choices="(('en-us', 'English'), ('fr-fr', 'French'))", default='en-us', help_text='The language in which the user wants to see the interface.', max_length=10, verbose_name='language'),
-        ),
-    ]

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/models.py

@@ -1,606 +0,0 @@
-"""
-Declare and configure the models for the Meet core application
-"""
-
-import uuid
-from logging import getLogger
-from typing import List
-
-from django.conf import settings
-from django.contrib.auth import models as auth_models
-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.functional import lazy
-from django.utils.text import capfirst, slugify
-from django.utils.translation import gettext_lazy as _
-
-from timezone_field import TimeZoneField
-
-logger = getLogger(__name__)
-
-
-class RoleChoices(models.TextChoices):
-    """Role choices."""
-
-    MEMBER = "member", _("Member")
-    ADMIN = "administrator", _("Administrator")
-    OWNER = "owner", _("Owner")
-
-    @classmethod
-    def check_administrator_role(cls, role):
-        """Check if a role is administrator."""
-        return role in [cls.ADMIN, cls.OWNER]
-
-    @classmethod
-    def check_owner_role(cls, role):
-        """Check if a role is owner."""
-        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 BaseModel(models.Model):
-    """
-    Serves as an abstract base model for other models, ensuring that records are validated
-    before saving as Django doesn't do it by default.
-
-    Includes fields common to all models: a UUID primary key and creation/update timestamps.
-    """
-
-    id = models.UUIDField(
-        verbose_name=_("id"),
-        help_text=_("primary key for the record as UUID"),
-        primary_key=True,
-        default=uuid.uuid4,
-        editable=False,
-    )
-    created_at = models.DateTimeField(
-        verbose_name=_("created on"),
-        help_text=_("date and time at which a record was created"),
-        auto_now_add=True,
-        editable=False,
-    )
-    updated_at = models.DateTimeField(
-        verbose_name=_("updated on"),
-        help_text=_("date and time at which a record was last updated"),
-        auto_now=True,
-        editable=False,
-    )
-
-    class Meta:
-        abstract = True
-
-    def save(self, *args, **kwargs):
-        """Call `full_clean` before saving."""
-        self.full_clean()
-        super().save(*args, **kwargs)
-
-
-class User(AbstractBaseUser, BaseModel, auth_models.PermissionsMixin):
-    """User model to work with OIDC only authentication."""
-
-    sub_validator = validators.RegexValidator(
-        regex=r"^[\w.@+-]+\Z",
-        message=_(
-            "Enter a valid sub. This value may contain only letters, "
-            "numbers, and @/./+/-/_ characters."
-        ),
-    )
-
-    sub = models.CharField(
-        _("sub"),
-        help_text=_(
-            "Required. 255 characters or fewer. Letters, numbers, and @/./+/-/_ characters only."
-        ),
-        max_length=255,
-        unique=True,
-        validators=[sub_validator],
-        blank=True,
-        null=True,
-    )
-    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
-    admin_email = models.EmailField(
-        _("admin email address"), unique=True, blank=True, null=True
-    )
-    full_name = models.CharField(_("full name"), max_length=100, null=True, blank=True)
-    short_name = models.CharField(
-        _("short name"), max_length=100, null=True, blank=True
-    )
-    language = models.CharField(
-        max_length=10,
-        choices=lazy(lambda: settings.LANGUAGES, tuple)(),
-        default=settings.LANGUAGE_CODE,
-        verbose_name=_("language"),
-        help_text=_("The language in which the user wants to see the interface."),
-    )
-    timezone = TimeZoneField(
-        choices_display="WITH_GMT_OFFSET",
-        use_pytz=False,
-        default=settings.TIME_ZONE,
-        help_text=_("The timezone in which the user wants to see times."),
-    )
-    is_device = models.BooleanField(
-        _("device"),
-        default=False,
-        help_text=_("Whether the user is a device or a real user."),
-    )
-    is_staff = models.BooleanField(
-        _("staff status"),
-        default=False,
-        help_text=_("Whether the user can log into this admin site."),
-    )
-    is_active = models.BooleanField(
-        _("active"),
-        default=True,
-        help_text=_(
-            "Whether this user should be treated as active. "
-            "Unselect this instead of deleting accounts."
-        ),
-    )
-
-    objects = auth_models.UserManager()
-
-    USERNAME_FIELD = "admin_email"
-    REQUIRED_FIELDS = []
-
-    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):
-        """Email this user."""
-        if not self.email:
-            raise ValueError("User has no email address.")
-        mail.send_mail(subject, message, from_email, [self.email], **kwargs)
-
-    def get_teams(self):
-        """
-        Get list of teams in which the user is, as a list of strings.
-        Must be cached if retrieved remotely.
-        """
-        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 []
-
-
-class Resource(BaseModel):
-    """Model to define access control"""
-
-    is_public = models.BooleanField(default=settings.RESOURCE_DEFAULT_IS_PUBLIC)
-    users = models.ManyToManyField(
-        User,
-        through="ResourceAccess",
-        through_fields=("resource", "user"),
-        related_name="resources",
-    )
-
-    class Meta:
-        db_table = "meet_resource"
-        verbose_name = _("Resource")
-        verbose_name_plural = _("Resources")
-
-    def __str__(self):
-        try:
-            return self.name
-        except AttributeError:
-            return f"Resource {self.id!s}"
-
-    def get_role(self, user):
-        """
-        Determine the role of a given user in this resource.
-        """
-        if not user or not user.is_authenticated:
-            return None
-
-        role = None
-        for access in self.accesses.filter(user=user):
-            if access.role == RoleChoices.OWNER:
-                return RoleChoices.OWNER
-            if access.role == RoleChoices.ADMIN:
-                role = RoleChoices.ADMIN
-            if access.role == RoleChoices.MEMBER and role != RoleChoices.ADMIN:
-                role = RoleChoices.MEMBER
-        return role
-
-    def is_administrator(self, user):
-        """
-        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."""
-        return RoleChoices.check_owner_role(self.get_role(user))
-
-
-class ResourceAccess(BaseModel):
-    """Link table between resources and users"""
-
-    resource = models.ForeignKey(
-        Resource,
-        on_delete=models.CASCADE,
-        related_name="accesses",
-    )
-    user = models.ForeignKey(User, on_delete=models.CASCADE, related_name="accesses")
-    role = models.CharField(
-        max_length=20, choices=RoleChoices.choices, default=RoleChoices.MEMBER
-    )
-
-    class Meta:
-        db_table = "meet_resource_access"
-        ordering = ("-created_at",)
-        verbose_name = _("Resource access")
-        verbose_name_plural = _("Resource accesses")
-        constraints = [
-            models.UniqueConstraint(
-                fields=["user", "resource"],
-                name="resource_access_unique_user_resource",
-                violation_error_message=_(
-                    "Resource access with this User and Resource already exists."
-                ),
-            ),
-        ]
-
-    def __str__(self):
-        role = capfirst(self.get_role_display())
-        try:
-            resource = self.resource.name
-        except AttributeError:
-            resource = f"resource {self.resource_id!s}"
-
-        return f"{role:s} role for {self.user!s} on {resource:s}"
-
-    def save(self, *args, **kwargs):
-        """Make sure we keep at least one owner for the resource."""
-        if self.pk and self.role != RoleChoices.OWNER:
-            accesses = self._meta.model.objects.filter(
-                resource=self.resource, role=RoleChoices.OWNER
-            ).only("pk")
-            if len(accesses) == 1 and accesses[0].pk == self.pk:
-                raise PermissionDenied("A resource should keep at least one owner.")
-        return super().save(*args, **kwargs)
-
-    def delete(self, *args, **kwargs):
-        """Disallow deleting the last of the Mohicans."""
-        if (
-            self.role == RoleChoices.OWNER
-            and self._meta.model.objects.filter(
-                resource=self.resource, role=RoleChoices.OWNER
-            ).count()
-            == 1
-        ):
-            raise PermissionDenied("A resource should keep at least one owner.")
-        return super().delete(*args, **kwargs)
-
-
-class Room(Resource):
-    """Model for one room"""
-
-    name = models.CharField(max_length=500)
-    resource = models.OneToOneField(
-        Resource,
-        on_delete=models.CASCADE,
-        parent_link=True,
-        primary_key=True,
-    )
-    slug = models.SlugField(max_length=100, blank=True, null=True, unique=True)
-
-    configuration = models.JSONField(
-        blank=True,
-        default=dict,
-        verbose_name=_("Visio room configuration"),
-        help_text=_("Values for Visio parameters to configure the room."),
-    )
-
-    class Meta:
-        db_table = "meet_room"
-        ordering = ("name",)
-        verbose_name = _("Room")
-        verbose_name_plural = _("Rooms")
-
-    def __str__(self):
-        return capfirst(self.name)
-
-    def clean_fields(self, exclude=None):
-        """
-        Automatically generate the slug from the name and make sure it does not look like a UUID.
-
-        We don't want any overlapping between the `slug` and the `id` fields because they can
-        both be used to get a room detail view on the API.
-        """
-        self.slug = slugify(self.name)
-        try:
-            uuid.UUID(self.slug)
-        except ValueError:
-            pass
-        else:
-            raise ValidationError({"name": f'Room name "{self.name:s}" is reserved.'})
-        super().clean_fields(exclude=exclude)
-
-
-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,
-        }
-
-
-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/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'"