🔖(patch) release version 1.7.1

Update all version files and changelog for patch release.

.github/workflows/docker-hub.yml

@@ -1,4 +1,5 @@
 name: Docker Hub Workflow
+run-name: Docker Hub Workflow
 
 on:
   workflow_dispatch:
@@ -15,6 +16,44 @@ env:
   DOCKER_USER: 1001:127
 
 jobs:
+  trivy-scan:
+    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: "people,secrets"
+      -
+        name: Checkout repository
+        uses: actions/checkout@v2
+        with:
+          submodules: recursive
+          token: ${{ steps.app-token.outputs.token }}
+      -
+        name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: |
+            lasuite/people-backend
+            lasuite/people-frontend
+      -
+        name: Run trivy scan (backend)
+        uses: numerique-gouv/action-trivy-cache@main
+        with:
+          docker-build-args: '--target backend-production -f Dockerfile'
+          docker-image-name: 'docker.io/lasuite/people-backend:${{ github.sha }}'
+      -
+        name: Run trivy scan (frontend)
+        uses: numerique-gouv/action-trivy-cache@main
+        with:
+          docker-build-args: '--target frontend-production -f Dockerfile'
+          docker-image-name: 'docker.io/lasuite/people-frontend:${{ github.sha }}'
+
   build-and-push-backend:
     runs-on: ubuntu-latest
     steps:
@@ -48,9 +87,16 @@ jobs:
         name: Login to DockerHub
         if: github.event_name != 'pull_request'
         run: echo "$DOCKER_HUB_PASSWORD" | docker login -u "$DOCKER_HUB_USER" --password-stdin
+      - name: create-version-json
+        id: create-version-json
+        uses: jsdaniell/create-json@v1.2.3
+        with:
+          name: "version.json"
+          json: '{"source":"${{github.repository}}", "version":"${{github.ref_name}}", "commit":"${{github.sha}}", "build": "NA"}'
+          dir: 'src/backend'
       -
         name: Build and push
-        uses: docker/build-push-action@v5
+        uses: docker/build-push-action@v6
         with:
           context: .
           target: backend-production
@@ -88,13 +134,20 @@ jobs:
         with:
           secret-file: secrets/numerique-gouv/people/secrets.enc.env
           age-key: ${{ secrets.SOPS_PRIVATE }}
+      - name: create-version-json
+        id: create-version-json
+        uses: jsdaniell/create-json@v1.2.3
+        with:
+          name: "version.json"
+          json: '{"source":"${{github.repository}}", "version":"${{github.ref_name}}", "commit":"${{github.sha}}", "build": "NA"}'
+          dir: 'src/frontend/apps/desk'
       -
         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@v5
+        uses: docker/build-push-action@v6
         with:
           context: .
           target: frontend-production

.github/workflows/people.yml

@@ -16,7 +16,7 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
-            fetch-depth: 0
+          fetch-depth: 0
       - name: show
         run: git log
       - name: Enforce absence of print statements in code
@@ -39,7 +39,7 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
-            fetch-depth: 0
+          fetch-depth: 0
       - name: Check that the CHANGELOG has been modified in the current branch
         run: git whatchanged --name-only --pretty="" origin/${{ github.event.pull_request.base.ref }}..HEAD | grep CHANGELOG
 
@@ -139,7 +139,7 @@ jobs:
         with:
           path: 'src/frontend/**/node_modules'
           key: front-node_modules-${{ hashFiles('src/frontend/**/yarn.lock') }}
-        
+
       - name: Check linting
         run: cd src/frontend/ && yarn lint
 
@@ -147,6 +147,11 @@ jobs:
     runs-on: ubuntu-latest
     needs: [build-mails, build-front]
     timeout-minutes: 10
+    strategy:
+      fail-fast: false
+      matrix:
+        shardIndex: [1, 2, 3, 4]
+        shardTotal: [4]
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -196,15 +201,35 @@ jobs:
         run: cd src/frontend/apps/e2e && yarn install
 
       - name: Run e2e tests
-        run: cd src/frontend/ && yarn e2e:test
+        run: cd src/frontend/ && yarn e2e:test --shard=${{ matrix.shardIndex }}/${{ matrix.shardTotal }}
+
+      - name: Save logs
+        if: always()
+        run: docker compose logs > src/frontend/apps/e2e/report/logs.txt
+
+      - name: Save Dimail logs
+        if: always()
+        run: docker compose logs dimail > src/frontend/apps/e2e/report/dimail-logs.txt
 
       - uses: actions/upload-artifact@v4
         if: always()
         with:
-          name: playwright-report
+          name: playwright-report-${{ matrix.shardIndex }}
           path: src/frontend/apps/e2e/report/
           retention-days: 7
 
+  tests-e2e-feedback:
+    runs-on: ubuntu-latest
+    needs: [test-e2e]
+    if: always()
+    steps:
+      - name: All tests ok
+        if: ${{ !(contains(needs.*.result, 'failure')) }}
+        run: exit 0
+      - name: Some tests failed
+        if: ${{ contains(needs.*.result, 'failure') }}
+        run: exit 1
+
   build-mails:
     runs-on: ubuntu-latest
     defaults:
@@ -226,8 +251,8 @@ jobs:
       - name: Persist mails' templates
         uses: actions/upload-artifact@v4
         with:
-            name: mails-templates
-            path: src/backend/core/templates/mail
+          name: mails-templates
+          path: src/backend/core/templates/mail
 
   lint-back:
     runs-on: ubuntu-latest

.gitignore

@@ -42,7 +42,6 @@ env.bak/
 venv.bak/
 env.d/development/*
 !env.d/development/*.dist
-env.d/terraform
 
 # npm
 node_modules
@@ -59,11 +58,6 @@ src/frontend/tsclient
 # Logs
 *.log
 
-# Terraform
-.terraform
-*.tfstate
-*.tfstate.backup
-
 # Test & lint
 .coverage
 coverage.json

.sops.yaml

@@ -8,3 +8,4 @@ creation_rules:
       - age12g6f5fse25tgrwweleh4jls3qs52hey2edh759smulwmk5lnzadslu2cp3 # Antoine Lebaud
       - age1hnhuzj96ktkhpyygvmz0x9h8mfvssz7ss6emmukags644mdhf4msajk93r # Samuel Paccoud
       - age1tl80n23wq6zxegupwn70ew0yp225ua5v4dk800x7g2w6pvlxz46qk592pa # Marie Pupo Jeammet
+      - age1rjchule5sncn8r8gfph07muee6vzx4wqfrtldt5jjzke4vlfxy2qqplfvc # Quentin Bey

CHANGELOG.md

@@ -8,6 +8,69 @@ and this project adheres to
 
 ## [Unreleased]
 
+## [1.7.1] - 2024-11-28
+
+## [1.7.0] - 2024-11-28
+
+### Added
+
+- ✨(mailbox) allow to activate mailbox
+- ✨(mailbox) allow to disable mailbox
+- ✨(backend) add ServiceProvider #522
+- 💄(admin) allow header color customization #552 
+- ✨(organization) add API endpoints #551
+
+### Fixed
+
+-  🐛(admin) add organization on user #555
+
+## [1.6.1] - 2024-11-22
+
+### Fixed
+
+- 🩹(mailbox) fix status of current mailboxes
+- 🚑️(backend) fix claim contains non-user field #548
+
+## [1.6.0] - 2024-11-20
+
+### Removed
+
+- 🔥(teams) remove search by trigram for team access and contact
+
+### Added
+
+- ✨(domains) allow creation of "pending" mailboxes
+- ✨(teams) allow team management for team admins/owners #509
+
+### Fixed
+
+-  🔊(backend) update logger config to info #542
+
+## [1.5.0] - 2024-11-14
+
+### Removed
+
+- ⬆️(dependencies) remove unneeded dependencies
+- 🔥(teams) remove pagination of teams listing
+- 🔥(teams) remove search users by trigram
+- 🗃️(teams) remove `slug` field
+
+### Added
+
+- ✨(dimail) send domain creation requests to dimail #454
+- ✨(dimail) synchronize mailboxes from dimail to our db #453
+- ✨(ci) add security scan #429
+- ✨(teams) register contacts on admin views
+
+### Fixed
+
+- 🐛(mail) fix display button on outlook
+- 💚(ci) improve E2E tests #492
+- 🔧(sentry) restore default integrations
+- 🔇(backend) remove Sentry duplicated warning/errors
+- 👷(ci) add sharding e2e tests  #467
+- 🐛(dimail) fix unexpected status_code for proper debug #454
+
 ## [1.4.1] - 2024-10-23
 
 ### Fixed
@@ -35,6 +98,7 @@ and this project adheres to
 - ✨(api) add RELEASE version on config endpoint #459
 - ✨(backend) manage roles on domain admin view
 - ✨(frontend) show version number in footer #369
+- 👔(backend) add Organization model
 
 ### Changed
 
@@ -124,7 +188,12 @@ and this project adheres to
 - ✨(domains) create and manage domains on admin + API
 - ✨(domains) mailbox creation + link to email provisioning API
 
-[unreleased]: https://github.com/numerique-gouv/people/compare/v1.4.1...main
+[unreleased]: https://github.com/numerique-gouv/people/compare/v1.7.1...main
+[1.7.1]: https://github.com/numerique-gouv/people/releases/v1.7.1
+[1.7.0]: https://github.com/numerique-gouv/people/releases/v1.7.0
+[1.6.1]: https://github.com/numerique-gouv/people/releases/v1.6.1
+[1.6.0]: https://github.com/numerique-gouv/people/releases/v1.6.0
+[1.5.0]: https://github.com/numerique-gouv/people/releases/v1.5.0
 [1.4.1]: https://github.com/numerique-gouv/people/releases/v1.4.1
 [1.4.0]: https://github.com/numerique-gouv/people/releases/v1.4.0
 [1.3.1]: https://github.com/numerique-gouv/people/releases/v1.3.1

Dockerfile

@@ -1,18 +1,17 @@
 # Django People
 
 # ---- base image to inherit from ----
-FROM python:3.10-slim-bullseye as base
+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
+RUN python -m pip install --upgrade pip setuptools
 
 # Upgrade system packages to install security updates
-RUN apt-get update && \
-  apt-get -y upgrade && \
-  rm -rf /var/lib/apt/lists/*
+RUN apk update && \
+  apk upgrade
 
 ### ---- Front-end dependencies image ----
-FROM node:20 as frontend-deps
+FROM node:20 AS frontend-deps
 
 WORKDIR /deps
 
@@ -25,7 +24,7 @@ COPY ./src/frontend/packages/eslint-config-people/package.json ./packages/eslint
 RUN yarn --frozen-lockfile
 
 ### ---- Front-end builder dev image ----
-FROM node:20 as frontend-builder-dev
+FROM node:20 AS frontend-builder-dev
 
 WORKDIR /builder
 
@@ -35,12 +34,12 @@ COPY ./src/frontend .
 WORKDIR ./apps/desk
 
 ### ---- Front-end builder image ----
-FROM frontend-builder-dev as frontend-builder
+FROM frontend-builder-dev AS frontend-builder
 
 RUN yarn build
 
 # ---- Front-end image ----
-FROM nginxinc/nginx-unprivileged:1.25 as frontend-production
+FROM nginxinc/nginx-unprivileged:1.26-alpine AS frontend-production
 
 # Un-privileged user running the application
 ARG DOCKER_USER
@@ -61,7 +60,7 @@ CMD ["nginx", "-g", "daemon off;"]
 
 
 # ---- Back-end builder image ----
-FROM base as back-builder
+FROM base AS back-builder
 
 WORKDIR /builder
 
@@ -73,7 +72,7 @@ RUN mkdir /install && \
 
 
 # ---- mails ----
-FROM node:20 as mail-builder
+FROM node:20 AS mail-builder
 
 COPY ./src/mail /mail/app
 
@@ -84,15 +83,13 @@ RUN yarn install --frozen-lockfile && \
 
 
 # ---- static link collector ----
-FROM base as link-collector
+FROM base AS link-collector
 ARG PEOPLE_STATIC_ROOT=/data/static
 
 # Install libpangocairo & rdfind
-RUN apt-get update && \
-    apt-get install -y \
-      libpangocairo-1.0-0 \
-      rdfind && \
-    rm -rf /var/lib/apt/lists/*
+RUN apk add \
+  pango \
+  rdfind
 
 # Copy installed python dependencies
 COPY --from=back-builder /install /usr/local
@@ -111,21 +108,18 @@ RUN DJANGO_CONFIGURATION=Build DJANGO_JWT_PRIVATE_SIGNING_KEY=Dummy \
 RUN rdfind -makesymlinks true -followsymlinks true -makeresultsfile false ${PEOPLE_STATIC_ROOT}
 
 # ---- Core application image ----
-FROM base as core
+FROM base AS core
 
 ENV PYTHONUNBUFFERED=1
 
 # Install required system libs
-RUN apt-get update && \
-    apt-get install -y \
-      gettext \
-      libcairo2 \
-      libffi-dev \
-      libgdk-pixbuf2.0-0 \
-      libpango-1.0-0 \
-      libpangocairo-1.0-0 \
-      shared-mime-info && \
-  rm -rf /var/lib/apt/lists/*
+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
@@ -149,15 +143,13 @@ WORKDIR /app
 ENTRYPOINT [ "/usr/local/bin/entrypoint" ]
 
 # ---- Development image ----
-FROM core as backend-development
+FROM core AS backend-development
 
 # Switch back to the root user to install development dependencies
 USER root:root
 
 # Install psql
-RUN apt-get update && \
-    apt-get install -y postgresql-client && \
-    rm -rf /var/lib/apt/lists/*
+RUN apk add postgresql-client
 
 # Uninstall people and re-install it in editable mode along with development
 # dependencies
@@ -177,7 +169,7 @@ ENV DB_HOST=postgresql \
 CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]
 
 # ---- Production image ----
-FROM core as backend-production
+FROM core AS backend-production
 
 ARG PEOPLE_STATIC_ROOT=/data/static
 

Makefile

@@ -131,11 +131,6 @@ demo: ## flush db then create a demo for load testing purpose
 	@$(MANAGE) create_demo
 .PHONY: demo
 
-reset-dimail-container:
-	@$(COMPOSE) up --force-recreate -d dimail
-	@$(MAKE) setup-dimail-db
-.PHONY: reset-dimail-container
-
 
 # Nota bene: Black should come after isort just in case they don't agree...
 lint: ## lint back-end python sources
@@ -283,6 +278,10 @@ i18n-generate-and-upload: \
 # -- INTEROPERABILTY
 # -- Dimail configuration
 
+recreate-dimail-container:
+	@$(COMPOSE) up --force-recreate -d dimail
+.PHONY: recreate-dimail-container
+
 dimail-setup-db:
 	@echo "$(BOLD)Populating database of local dimail API container$(RESET)"
 	@$(MANAGE) setup_dimail_db

bin/_config.sh

@@ -5,7 +5,6 @@ set -eo pipefail
 REPO_DIR="$(cd "$( dirname "${BASH_SOURCE[0]}" )/.." && pwd)"
 UNSET_USER=0
 
-TERRAFORM_DIRECTORY="./env.d/terraform"
 COMPOSE_FILE="${REPO_DIR}/docker-compose.yml"
 COMPOSE_PROJECT="people"
 
@@ -92,66 +91,3 @@ function _dc_exec() {
 function _django_manage() {
     _dc_run "app-dev" python manage.py "$@"
 }
-
-# _set_openstack_project: select an OpenStack project from the openrc files defined in the
-# terraform directory.
-#
-# usage: _set_openstack_project
-#
-# If necessary the script will prompt the user to choose a project from those available
-function _set_openstack_project() {
-
-    declare prompt
-    declare -a projects
-    declare -i default=1
-    declare -i choice=0
-    declare -i n_projects
-
-    # List projects by looking in the "./env.d/terraform" directory
-    # and store them in an array
-    read -r -a projects <<< "$(
-        find "${TERRAFORM_DIRECTORY}" -maxdepth 1 -mindepth 1 -type d |
-        sed 's|'"${TERRAFORM_DIRECTORY}\/"'||' |
-        xargs
-    )"
-    nb_projects=${#projects[@]}
-
-    if [[ ${nb_projects} -le 0 ]]; then
-        echo "There are no OpenStack projects defined..." >&2
-        echo "To add one, create a subdirectory in \"${TERRAFORM_DIRECTORY}\" with the name" \
-            "of your project and copy your \"openrc.sh\" file into it." >&2
-        exit 10
-    fi
-
-    if [[ ${nb_projects} -gt 1 ]]; then
-        prompt="Select an OpenStack project to target:\\n"
-        for (( i=0; i<nb_projects; i++ )); do
-            prompt+="[$((i+1))] ${projects[$i]}"
-            if [[ $((i+1)) -eq ${default} ]]; then
-                prompt+=" (default)"
-            fi
-            prompt+="\\n"
-        done
-        prompt+="If your OpenStack project is not listed, add it to the \"env.d/terraform\" directory.\\n"
-        prompt+="Your choice: "
-        read -r -p "$(echo -e "${prompt}")" choice
-
-        if [[ ${choice} -gt nb_projects ]]; then
-            (>&2 echo "Invalid choice ${choice} (should be <= ${nb_projects})")
-            exit 11
-        fi
-
-        if [[ ${choice} -le 0 ]]; then
-            choice=${default}
-        fi
-    fi
-
-    project=${projects[$((choice-1))]}
-    # Check that the openrc.sh file exists for this project
-    if [ ! -f "${TERRAFORM_DIRECTORY}/${project}/openrc.sh" ]; then
-        (>&2 echo "Missing \"openrc.sh\" file in \"${TERRAFORM_DIRECTORY}/${project}\". Check documentation.")
-        exit 12
-    fi
-
-    echo "${project}"
-}

bin/state

@@ -1,25 +0,0 @@
-#!/usr/bin/env bash
-set -eo pipefail
-
-source "$(dirname "${BASH_SOURCE[0]}")/_config.sh"
-
-project=$(_set_openstack_project)
-echo "Using \"${project}\" project..."
-
-source "${TERRAFORM_DIRECTORY}/${project}/openrc.sh"
-
-# Run Terraform commands in the Hashicorp docker container via docker compose
-# shellcheck disable=SC2068
-DOCKER_USER="$(id -u):$(id -g)" \
-    PROJECT="${project}" \
-    docker compose run --rm \
-    -e OS_AUTH_URL \
-    -e OS_IDENTITY_API_VERSION \
-    -e OS_USER_DOMAIN_NAME \
-    -e OS_PROJECT_DOMAIN_NAME \
-    -e OS_TENANT_ID \
-    -e OS_TENANT_NAME \
-    -e OS_USERNAME \
-    -e OS_PASSWORD \
-    -e OS_REGION_NAME \
-    terraform-state "$@"

bin/terraform

@@ -1,26 +0,0 @@
-#!/usr/bin/env bash
-set -eo pipefail
-
-source "$(dirname "${BASH_SOURCE[0]}")/_config.sh"
-
-project=$(_set_openstack_project)
-echo "Using \"${project}\" project..."
-
-source "${TERRAFORM_DIRECTORY}/${project}/openrc.sh"
-
-# Run Terraform commands in the Hashicorp docker container via docker compose
-# shellcheck disable=SC2068
-DOCKER_USER="$(id -u):$(id -g)" \
-    PROJECT="${project}" \
-    docker compose run --rm \
-    -e OS_AUTH_URL \
-    -e OS_IDENTITY_API_VERSION \
-    -e OS_USER_DOMAIN_NAME \
-    -e OS_PROJECT_DOMAIN_NAME \
-    -e OS_TENANT_ID \
-    -e OS_TENANT_NAME \
-    -e OS_USERNAME \
-    -e OS_PASSWORD \
-    -e OS_REGION_NAME \
-    -e TF_VAR_user_name \
-    terraform "$@"

docker-compose.yml

@@ -35,6 +35,7 @@ services:
       - ./data/media:/data/media
       - ./data/static:/data/static
     depends_on:
+        - dimail
         - postgresql
         - mailcatcher
         - redis
@@ -116,22 +117,6 @@ services:
     volumes:
       - ".:/app"
 
-  terraform-state:
-    image: hashicorp/terraform:1.6
-    environment:
-      - TF_WORKSPACE=${PROJECT:-} # avoid env conflict in local state
-    user: ${DOCKER_USER:-1000}
-    working_dir: /app
-    volumes:
-      - ./src/terraform/create_state_bucket:/app
-
-  terraform:
-    image: hashicorp/terraform:1.6
-    user: ${DOCKER_USER:-1000}
-    working_dir: /app
-    volumes:
-      - ./src/terraform:/app
-
   kc_postgresql:
       image: postgres:14.3
       ports:
@@ -168,7 +153,9 @@ services:
       - kc_postgresql
 
   dimail: 
-    image: registry.mim-libre.fr/dimail/dimail-api:latest
+    entrypoint: /opt/dimail-api/start-dev.sh
+    image: registry.mim-libre.fr/dimail/dimail-api:v0.0.13
+    pull_policy: always
     environment:
       DIMAIL_MODE: FAKE
       DIMAIL_JWT_SECRET: fake_jwt_secret

docker/auth/realm.json

@@ -99,6 +99,216 @@
         }
       ],
       "realmRoles": ["user"]
+    },
+    {
+      "username": "jean.team-member",
+      "email": "jean.team-member@example.com",
+      "firstName": "E2E",
+      "lastName": "Group Member",
+      "enabled": true,
+      "credentials": [
+        {
+          "type": "password",
+          "value": "password-e2e-jean.team-member"
+        }
+      ],
+      "realmRoles": ["user"]
+    },
+        {
+      "username": "jean.team-administrator",
+      "email": "jean.team-administrator@example.com",
+      "firstName": "E2E",
+      "lastName": "Group Administrator",
+      "enabled": true,
+      "credentials": [
+        {
+          "type": "password",
+          "value": "password-e2e-jean.team-administrator"
+        }
+      ],
+      "realmRoles": ["user"]
+    },
+        {
+      "username": "jean.team-owner",
+      "email": "jean.team-owner@example.com",
+      "firstName": "E2E",
+      "lastName": "Group Owner",
+      "enabled": true,
+      "credentials": [
+        {
+          "type": "password",
+          "value": "password-e2e-jean.team-owner"
+        }
+      ],
+      "realmRoles": ["user"]
+    },
+    {
+      "username": "jean.mail-member",
+      "email": "jean.mail-member@example.com",
+      "firstName": "E2E",
+      "lastName": "Mailbox Member",
+      "enabled": true,
+      "credentials": [
+        {
+          "type": "password",
+          "value": "password-e2e-jean.mail-member"
+        }
+      ],
+      "realmRoles": ["user"]
+    },
+    {
+      "username": "jean.mail-administrator",
+      "email": "jean.mail-administrator@example.com",
+      "firstName": "E2E",
+      "lastName": "Mailbox Administrator",
+      "enabled": true,
+      "credentials": [
+        {
+          "type": "password",
+          "value": "password-e2e-jean.mail-administrator"
+        }
+      ],
+      "realmRoles": ["user"]
+    },
+    {
+      "username": "jean.mail-owner",
+      "email": "jean.mail-owner@example.com",
+      "firstName": "E2E",
+      "lastName": "Mailbox Owner",
+      "enabled": true,
+      "credentials": [
+        {
+          "type": "password",
+          "value": "password-e2e-jean.mail-owner"
+        }
+      ],
+      "realmRoles": ["user"]
+    },
+    {
+      "username": "jean.team-member-mail-member",
+      "email": "jean.team-member-mail-member@example.com",
+      "firstName": "E2E",
+      "lastName": "Group Member Mailbox Member",
+      "enabled": true,
+      "credentials": [
+        {
+          "type": "password",
+          "value": "password-e2e-jean.team-member-mail-member"
+        }
+      ],
+      "realmRoles": ["user"]
+    },
+    {
+      "username": "jean.team-member-mail-administrator",
+      "email": "jean.team-member-mail-administrator@example.com",
+      "firstName": "E2E",
+      "lastName": "Group Member Mailbox Administrator",
+      "enabled": true,
+      "credentials": [
+        {
+          "type": "password",
+          "value": "password-e2e-jean.team-member-mail-administrator"
+        }
+      ],
+      "realmRoles": ["user"]
+    },
+    {
+      "username": "jean.team-member-mail-owner",
+      "email": "jean.team-member-mail-owner@example.com",
+      "firstName": "E2E",
+      "lastName": "Group Member Mailbox Owner",
+      "enabled": true,
+      "credentials": [
+        {
+          "type": "password",
+          "value": "password-e2e-jean.team-member-mail-owner"
+        }
+      ],
+      "realmRoles": ["user"]
+    },
+    {
+      "username": "jean.team-administrator-mail-member",
+      "email": "jean.team-administrator-mail-member@example.com",
+      "firstName": "E2E",
+      "lastName": "Group Administrator Mailbox Member",
+      "enabled": true,
+      "credentials": [
+        {
+          "type": "password",
+          "value": "password-e2e-jean.team-administrator-mail-member"
+        }
+      ],
+      "realmRoles": ["user"]
+    },
+    {
+      "username": "jean.team-administrator-mail-administrator",
+      "email": "jean.team-administrator-mail-administrator@example.com",
+      "firstName": "E2E",
+      "lastName": "Group Administrator Mailbox Administrator",
+      "enabled": true,
+      "credentials": [
+        {
+          "type": "password",
+          "value": "password-e2e-jean.team-administrator-mail-administrator"
+        }
+      ],
+      "realmRoles": ["user"]
+    },
+    {
+      "username": "jean.team-administrator-mail-owner",
+      "email": "jean.team-administrator-mail-owner@example.com",
+      "firstName": "E2E",
+      "lastName": "Group Administrator Mailbox Owner",
+      "enabled": true,
+      "credentials": [
+        {
+          "type": "password",
+          "value": "password-e2e-jean.team-administrator-mail-owner"
+        }
+      ],
+      "realmRoles": ["user"]
+    },
+    {
+      "username": "jean.team-owner-mail-member",
+      "email": "jean.team-owner-mail-member@example.com",
+      "firstName": "E2E",
+      "lastName": "Group Owner Mailbox Member",
+      "enabled": true,
+      "credentials": [
+        {
+          "type": "password",
+          "value": "password-e2e-jean.team-owner-mail-member"
+        }
+      ],
+      "realmRoles": ["user"]
+    },
+    {
+      "username": "jean.team-owner-mail-administrator",
+      "email": "jean.team-owner-mail-administrator@example.com",
+      "firstName": "E2E",
+      "lastName": "Group Owner Mailbox Administrator",
+      "enabled": true,
+      "credentials": [
+        {
+          "type": "password",
+          "value": "password-e2e-jean.team-owner-mail-administrator"
+        }
+      ],
+      "realmRoles": ["user"]
+    },
+    {
+      "username": "jean.team-owner-mail-owner",
+      "email": "jean.team-owner-mail-owner@example.com",
+      "firstName": "E2E",
+      "lastName": "Mailbox Owner",
+      "enabled": true,
+      "credentials": [
+        {
+          "type": "password",
+          "value": "password-e2e-jean.team-owner-mail-owner"
+        }
+      ],
+      "realmRoles": ["user"]
     }
   ],
   "roles": {

docs/interoperability/dimail.md

@@ -9,19 +9,29 @@ API and its documentation can be found [here](https://api.dev.ox.numerique.gouv.
 
 ## Architectural links of dimail
 
-As dimail's primary goal is to act as an interface between People and OX, its architecture is similar to that of People. A series of requests are sent from People to dimail upon creating domains, users and accesses.
+As dimail's primary goal is to act as an interface between People and OX, its architecture is similar to that of People. A series of requests are sent from People to dimail upon creating domains, users, permissions and mailboxes.
 
 ### Domains
 
-Upon creating a domain on People, the same domain is created on dimail and will undergo a series of checks. When all checks have passed, the domain is considered valid and mailboxes can be created on it. 
+Upon creating a domain on People, the same domain is created on dimail and will undergo a series of checks. When all checks have passed, the domain is considered enabled. 
+
+Domains in OX have a field called "context". Context is a shared space between domains, allowing users to discover users not only on their domain but on their entire context.
+
+### Mailboxes 
+
+Mailboxes can be created by a domain owners or administrators in People's domain tab.
+
+On enabled domains, mailboxes are created at the same time on dimail (and a confirmation email is sent to the secondary email).
+On pending/failed domains, mailboxes are only created locally with "pending" status and are sent to dimail upon domain's activation.
+On disabled domains, mailboxes creation is not allowed.
 
 ### Users
 
 The ones issuing requests. Dimail users will reflect domains owners and administrators on People, for logging purposes and to allow direct use of dimail, if desired. User reconciliation is made on user uuid provided by ProConnect.
 
-### Accesses
+### Permissions
 
-As for People, an access - a permissions (or "allows" in dimail) - grants an user permission to create objects on a domain.
+As for People, an access - a permissions (or an "allow" in dimail) - grants an user permission to create objects on a domain.
 
 Permissions requests are sent automatically upon : 
 - dimail database initialisation: 

docs/organizations.md

@@ -0,0 +1,41 @@
+# Organization model
+
+## Purpose
+
+The initial `Organization` model allows to regroup `User` and `Team` under a same object.
+
+While the purpose was purely technical in the first place, few features emerged afterward.
+
+
+## Link with the `User` model
+
+Each user must have a "default" organization. 
+
+When a user logs in:
+
+- The backend tries to get an existing organization from a "registration ID" or from the user's mail domain
+- If the organization does not exist, it is created using the "registration ID" and fallbacks on the user's mail domain
+- The user organization is set to this organization.
+
+**Note:** While deploying the new code, we allow the already existing user to not have one.
+
+
+## Link with the `Team` model
+
+Each team must have an organization. This organization is not defined by the user, but automatically set
+using the user's organization.
+
+The team's organization does not restrict the users who can be added to the team.
+
+There is currently no feature relying on the team organization.
+
+**Note:** While deploying the new code, we allow the teams to not have one.
+
+
+## Organization-related features
+
+### Organization UI
+
+A new interface can be created to allow users to see all members of an organization. 
+This could be used along with the contacts.
+

docs/serviceProviders.md

@@ -0,0 +1,28 @@
+# ServiceProvider model
+
+## Purpose
+
+The `ServiceProvider` model represents a ... service provider, also known as "tools using some data from this project".
+
+
+## Link with the `Organization` model
+
+An organization can be linked to several service providers. 
+The goal here, is to allow users of an organization to have access, to a service provider or not.
+The first implementation does not have any feature related, but the first feature will probably be
+to list applications visible in the "all application menu" (aka "la gaufre").
+
+
+## Link with the `Team` model
+
+A team can be linked to several service providers.
+This is used as a filter when a service provider calls the resource server, only the teams linked to
+this service provider are returned. This is mandatory for data segregation: we don't want all service
+providers to be able to list all data regarding other service providers.
+
+
+## Limitations
+
+There is currently no way to provision all the service providers automatically. So when a service provider
+creates a team via the resource server, we create the `ServiceProvider` on the fly, without any understandable name.
+This will need to be improved later.

docs/testsE2E.md

@@ -0,0 +1,51 @@
+# E2E tests
+
+## Run E2E tests
+
+``` bash
+# you need the dockers to be up and running
+make bootstrap
+
+# you will need to have few accounts in the database
+make demo FLUSH_ARGS='--no-input'
+
+# run the tests
+cd src/frontend/apps/e2e
+yarn test:ui --workers=1
+```
+
+A new browser window will open and you will be able to run the tests.
+
+## Available accounts
+
+The `make demo` command creates the following accounts:
+ - `jean.team-<role>@example.com` where `<role>` is one of `administrator`, `member`, `owner`:
+    this account only belong to a team with the specified role.
+ - `jean.mail-<role>@example.com` where `<role>` is one of `administrator`, `member`, `owner`:
+    this account only have a mailbox with the specified role access.
+ - `jean.team-<team_role>-mail-<domain_role>@example.com` with a combination of roles as for the
+    previous accounts.
+
+For each account, the password is `password-e2e-<username>`, for instance `password-e2e-jean.team-member`.
+
+In the E2E tests you can use these accounts to benefit from there accesses, 
+using the `keyCloakSignIn(page, browserName, <account_name>)`. The account name is the 
+username without the prefix `jean.`.
+
+``` typescript jsx
+await keyCloakSignIn(page, browserName, 'mail-owner');
+```
+
+The `keyCloakSignIn` function will sign in the user on Keycloak using the proper username and password.
+
+.. note::
+    This only works because the OIDC setting is set to fallback on user email.
+
+## Add a new account
+
+In case you need to add a new account for specific tests you need:
+- to create a new user with the same format in the backend database: 
+  update `[create_demo.py](../src/backend/demo/management/commands/create_demo.py)`
+- to create a new account in Keycloak: update [realm.json](../docker/auth/realm.json)
+- if the keycloak was running locally, you need to destroy its database and 
+  restart the database and the keycloak containers.

scripts/release.py

@@ -1,3 +1,5 @@
+# pylint: disable=line-too-long
+
 import datetime
 import os
 import re
@@ -95,10 +97,13 @@ def prepare_release(version, kind):
         run_command(f"git push origin {branch_to_release}", shell=True)
     sys.stdout.write(f"""
     PLEASE DO THE FOLLOWING INSTRUCTIONS:
-    --> Please submit PR and merge code to main than tag version
-    >> git tag -a v{version} 
+    --> Please submit PR and merge code to main 
+    --> Then do:
+    >> git checkout main
+    >> git pull
+    >> git tag v{version} 
     >> git push origin v{version} 
-    --> Please check docker image: https://hub.docker.com/r/lasuite/people-backend/tags
+    --> Please check and wait for the docker image v{version} to be published here: https://hub.docker.com/r/lasuite/people-backend/tags
     >> git tag -d preprod
     >> git tag preprod
     >> git push -f origin preprod

src/backend/.pylintrc

@@ -363,7 +363,8 @@ name-group=
 
 # Regular expression which should only match function or class names that do
 # not require a docstring.
-no-docstring-rgx=^_
+# Ignore: private stuff and `Params` class from FactoryBoy
+no-docstring-rgx=(^_|^Params$)
 
 # List of decorators that produce properties, such as abc.abstractproperty. Add
 # to this list to register other decorators that produce valid properties.

src/backend/__init__.py

@@ -0,0 +1 @@
+"""Root module."""

src/backend/admin/__init__.py

@@ -0,0 +1 @@
+"""People custom admin site."""

src/backend/admin/apps.py

@@ -0,0 +1,9 @@
+"""Custom Django admin site application configuration."""
+
+from django.contrib.admin.apps import AdminConfig
+
+
+class PeopleAdminConfig(AdminConfig):
+    """Declare our custom Django admin site."""
+
+    default_site = "admin.sites.PeopleAdminSite"

src/backend/admin/sites.py

@@ -0,0 +1,15 @@
+"""Custom Django admin site for the People app."""
+
+from django.conf import settings
+from django.contrib import admin
+
+
+class PeopleAdminSite(admin.AdminSite):
+    """People custom admin site."""
+
+    def each_context(self, request):
+        """Add custom context to the admin site."""
+        return super().each_context(request) | {
+            "ADMIN_HEADER_BACKGROUND": settings.ADMIN_HEADER_BACKGROUND,
+            "ADMIN_HEADER_COLOR": settings.ADMIN_HEADER_COLOR,
+        }

src/backend/admin/templates/admin/base_site.html

@@ -0,0 +1,10 @@
+{% extends "admin/base_site.html" %}
+
+{% block extrastyle %}{{ block.super }}
+<style>
+html[data-theme="light"], :root {
+  {% if ADMIN_HEADER_BACKGROUND %}--header-bg: {{ ADMIN_HEADER_BACKGROUND }};{% endif %}
+  {% if ADMIN_HEADER_COLOR %}--header-color: {{ ADMIN_HEADER_COLOR }};{% endif %}
+}
+</style>
+{% endblock %}

src/backend/core/__init__.py

@@ -0,0 +1 @@
+"""Core root module."""

src/backend/core/admin.py

@@ -18,6 +18,15 @@ class TeamAccessInline(admin.TabularInline):
     readonly_fields = ("created_at", "updated_at")
 
 
+class OrganizationAccessInline(admin.TabularInline):
+    """Inline admin class for organization accesses."""
+
+    autocomplete_fields = ["user", "organization"]
+    extra = 0
+    model = models.OrganizationAccess
+    readonly_fields = ("created_at", "updated_at")
+
+
 class TeamWebhookInline(admin.TabularInline):
     """Inline admin class for team webhooks."""
 
@@ -31,6 +40,7 @@ class TeamWebhookInline(admin.TabularInline):
 class UserAdmin(auth_admin.UserAdmin):
     """Admin class for the User model"""
 
+    autocomplete_fields = ["organization"]
     fieldsets = (
         (
             None,
@@ -39,6 +49,7 @@ class UserAdmin(auth_admin.UserAdmin):
                     "id",
                     "sub",
                     "password",
+                    "organization",
                 )
             },
         ),
@@ -67,9 +78,10 @@ class UserAdmin(auth_admin.UserAdmin):
             },
         ),
     )
-    inlines = (TeamAccessInline, MailDomainAccessInline)
+    inlines = (TeamAccessInline, MailDomainAccessInline, OrganizationAccessInline)
     list_display = (
         "get_user",
+        "organization",
         "created_at",
         "updated_at",
         "is_active",
@@ -97,14 +109,22 @@ class UserAdmin(auth_admin.UserAdmin):
     get_user.short_description = _("User")
 
 
+class TeamServiceProviderInline(admin.TabularInline):
+    """Inline admin class for service providers."""
+
+    can_delete = False
+    model = models.Team.service_providers.through
+    extra = 0
+
+
 @admin.register(models.Team)
 class TeamAdmin(admin.ModelAdmin):
     """Team admin interface declaration."""
 
-    inlines = (TeamAccessInline, TeamWebhookInline)
+    inlines = (TeamAccessInline, TeamWebhookInline, TeamServiceProviderInline)
+    exclude = ("service_providers",)  # Handled by the inline
     list_display = (
         "name",
-        "slug",
         "created_at",
         "updated_at",
     )
@@ -148,8 +168,8 @@ class InvitationAdmin(admin.ModelAdmin):
     )
 
     def get_readonly_fields(self, request, obj=None):
+        """Mark all fields read only, i.e. disable update."""
         if obj:
-            # all fields read only = disable update
             return self.fields
         return self.readonly_fields
 
@@ -162,5 +182,67 @@ class InvitationAdmin(admin.ModelAdmin):
         return super().change_view(request, object_id, extra_context=extra_context)
 
     def save_model(self, request, obj, form, change):
+        """Fill in current logged-in user as issuer."""
         obj.issuer = request.user
         obj.save()
+
+
+@admin.register(models.Contact)
+class ContactAdmin(admin.ModelAdmin):
+    """Contact admin interface declaration."""
+
+    list_display = (
+        "full_name",
+        "owner",
+        "base",
+    )
+
+
+class OrganizationServiceProviderInline(admin.TabularInline):
+    """Inline admin class for service providers."""
+
+    can_delete = False
+    model = models.Organization.service_providers.through
+    extra = 0
+
+
+@admin.register(models.Organization)
+class OrganizationAdmin(admin.ModelAdmin):
+    """Admin interface for organizations."""
+
+    list_display = (
+        "name",
+        "created_at",
+        "updated_at",
+    )
+    search_fields = ("name",)
+    inlines = (OrganizationAccessInline, OrganizationServiceProviderInline)
+    exclude = ("service_providers",)  # Handled by the inline
+
+
+@admin.register(models.OrganizationAccess)
+class OrganizationAccessAdmin(admin.ModelAdmin):
+    """Organization access admin interface declaration."""
+
+    autocomplete_fields = ("user", "organization")
+    list_display = (
+        "user",
+        "organization",
+        "role",
+        "created_at",
+        "updated_at",
+    )
+
+
+@admin.register(models.ServiceProvider)
+class ServiceProviderAdmin(admin.ModelAdmin):
+    """Admin interface for service providers."""
+
+    list_display = (
+        "name",
+        "audience_id",
+        "created_at",
+        "updated_at",
+    )
+    search_fields = ("name", "audience_id")
+    readonly_fields = ("created_at", "updated_at")

src/backend/core/api/client/__init__.py

@@ -0,0 +1 @@
+"""People core client API endpoints"""

src/backend/core/api/client/serializers.py

@@ -4,6 +4,7 @@ from rest_framework import exceptions, serializers
 from timezone_field.rest_framework import TimeZoneSerializerField
 
 from core import models
+from core.models import ServiceProvider
 
 
 class ContactSerializer(serializers.ModelSerializer):
@@ -34,6 +35,8 @@ class DynamicFieldsModelSerializer(serializers.ModelSerializer):
     """
 
     def __init__(self, *args, **kwargs):
+        """Pass arguments to superclass except 'fields', then drop fields not listed therein."""
+
         # Don't pass the 'fields' arg up to the superclass
         fields = kwargs.pop("fields", None)
 
@@ -48,12 +51,40 @@ class DynamicFieldsModelSerializer(serializers.ModelSerializer):
                 self.fields.pop(field_name)
 
 
+class OrganizationSerializer(serializers.ModelSerializer):
+    """Serialize organizations."""
+
+    abilities = serializers.SerializerMethodField()
+
+    class Meta:
+        model = models.Organization
+        fields = ["id", "name", "registration_id_list", "domain_list", "abilities"]
+        read_only_fields = ["id", "registration_id_list", "domain_list"]
+
+    def get_abilities(self, organization) -> dict:
+        """Return abilities of the logged-in user on the instance."""
+        request = self.context.get("request")
+        if request:
+            return organization.get_abilities(request.user)
+        return {}
+
+
+class UserOrganizationSerializer(serializers.ModelSerializer):
+    """Serialize organizations for users."""
+
+    class Meta:
+        model = models.Organization
+        fields = ["id", "name"]
+        read_only_fields = ["id", "name"]
+
+
 class UserSerializer(DynamicFieldsModelSerializer):
     """Serialize users."""
 
     timezone = TimeZoneSerializerField(use_pytz=False, required=True)
     email = serializers.ReadOnlyField()
     name = serializers.ReadOnlyField()
+    organization = UserOrganizationSerializer(read_only=True)
 
     class Meta:
         model = models.User
@@ -62,6 +93,7 @@ class UserSerializer(DynamicFieldsModelSerializer):
             "email",
             "language",
             "name",
+            "organization",
             "timezone",
             "is_device",
             "is_staff",
@@ -69,6 +101,41 @@ class UserSerializer(DynamicFieldsModelSerializer):
         read_only_fields = ["id", "name", "email", "is_device", "is_staff"]
 
 
+class UserMeSerializer(UserSerializer):
+    """
+    Serialize the current user.
+
+    Same as the `UserSerializer` but with abilities.
+    """
+
+    abilities = serializers.SerializerMethodField()
+    organization = UserOrganizationSerializer(read_only=True)
+
+    class Meta:
+        model = models.User
+        fields = [
+            "email",
+            "id",
+            "is_device",
+            "is_staff",
+            "language",
+            "name",
+            "organization",
+            "timezone",
+            # added fields
+            "abilities",
+        ]
+        read_only_fields = ["id", "name", "email", "is_device", "is_staff"]
+
+    def get_abilities(self, user: models.User) -> dict:
+        """Return abilities of the logged-in user on the instance."""
+        if user != self.context["request"].user:  # Should not happen
+            raise RuntimeError(
+                "UserMeSerializer.get_abilities: user is not the same as the request user",
+            )
+        return user.get_abilities()
+
+
 class TeamAccessSerializer(serializers.ModelSerializer):
     """Serialize team accesses."""
 
@@ -170,7 +237,9 @@ class TeamSerializer(serializers.ModelSerializer):
     """Serialize teams."""
 
     abilities = serializers.SerializerMethodField(read_only=True)
-    slug = serializers.SerializerMethodField()
+    service_providers = serializers.PrimaryKeyRelatedField(
+        queryset=ServiceProvider.objects.all(), many=True, required=False
+    )
 
     class Meta:
         model = models.Team
@@ -179,19 +248,33 @@ class TeamSerializer(serializers.ModelSerializer):
             "name",
             "accesses",
             "abilities",
-            "slug",
             "created_at",
             "updated_at",
+            "service_providers",
         ]
         read_only_fields = [
             "id",
             "accesses",
             "abilities",
-            "slug",
             "created_at",
             "updated_at",
         ]
 
+    def create(self, validated_data):
+        """Create a new team with organization enforcement."""
+        # When called as a resource server, we enforce the team service provider
+        if sp_audience := self.context.get("from_service_provider_audience", None):
+            service_provider, _created = models.ServiceProvider.objects.get_or_create(
+                audience_id=sp_audience
+            )
+            validated_data["service_providers"] = [service_provider]
+
+        # Note: this is not the purpose of this API to check the user has an organization
+        return super().create(
+            validated_data=validated_data
+            | {"organization_id": self.context["request"].user.organization_id}
+        )
+
     def get_abilities(self, team) -> dict:
         """Return abilities of the logged-in user on the instance."""
         request = self.context.get("request")
@@ -199,10 +282,6 @@ class TeamSerializer(serializers.ModelSerializer):
             return team.get_abilities(request.user)
         return {}
 
-    def get_slug(self, instance):
-        """Return slug from the team's name."""
-        return instance.get_slug()
-
 
 class InvitationSerializer(serializers.ModelSerializer):
     """Serialize invitations."""
@@ -237,3 +316,12 @@ class InvitationSerializer(serializers.ModelSerializer):
         attrs["team_id"] = team_id
         attrs["issuer"] = user
         return attrs
+
+
+class ServiceProviderSerializer(serializers.ModelSerializer):
+    """Serialize service providers."""
+
+    class Meta:
+        model = models.ServiceProvider
+        fields = ["id", "audience_id", "name"]
+        read_only_fields = ["id", "audience_id"]

src/backend/core/api/client/viewsets.py

@@ -1,9 +1,7 @@
 """API endpoints"""
 
 from django.conf import settings
-from django.contrib.postgres.search import TrigramSimilarity
-from django.db.models import Func, Max, OuterRef, Q, Subquery, Value
-from django.db.models.functions import Coalesce
+from django.db.models import OuterRef, Q, Subquery
 
 from rest_framework import (
     decorators,
@@ -19,8 +17,8 @@ from rest_framework import (
 from rest_framework.permissions import AllowAny
 
 from core import models
-
-from . import permissions, serializers
+from core.api import permissions
+from core.api.client import serializers
 
 SIMILARITY_THRESHOLD = 0.04
 
@@ -85,16 +83,23 @@ class SerializerPerActionMixin:
 
     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
+    Example:
+    ```
+    class MyViewSet(SerializerPerActionMixin, viewsets.GenericViewSet):
+        serializer_class = MySerializer
+        list_serializer_class = MyListSerializer
+        retrieve_serializer_class = MyRetrieveSerializer
+    ```
+    """
 
     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)
+        if serializer_class := getattr(self, f"{self.action}_serializer_class", None):
+            return serializer_class
+        return super().get_serializer_class()
 
 
 class Pagination(pagination.PageNumberPagination):
@@ -150,19 +155,11 @@ class ContactViewSet(
             overriding_contacts__isnull=True,
         )
 
-        # Search by case-insensitive and accent-insensitive trigram similarity
+        # Search by case-insensitive and accent-insensitive similarity
         if query := self.request.GET.get("q", ""):
-            query = Func(Value(query), function="unaccent")
-            similarity = TrigramSimilarity(
-                Func("full_name", function="unaccent"),
-                query,
-            ) + TrigramSimilarity(Func("short_name", function="unaccent"), query)
-            queryset = (
-                queryset.annotate(similarity=similarity)
-                .filter(
-                    similarity__gte=0.05
-                )  # Value determined by testing (test_api_contacts.py)
-                .order_by("-similarity")
+            queryset = queryset.filter(
+                Q(full_name__unaccent__icontains=query)
+                | Q(short_name__unaccent__icontains=query)
             )
 
         serializer = self.get_serializer(queryset, many=True)
@@ -175,21 +172,64 @@ class ContactViewSet(
         return super().perform_create(serializer)
 
 
+class OrganizationViewSet(
+    mixins.RetrieveModelMixin,
+    mixins.UpdateModelMixin,
+    viewsets.GenericViewSet,
+):
+    """
+    Organization ViewSet
+
+    GET /api/organizations/<organization_id>/
+        Return the organization details for the given id.
+
+    PUT /api/organizations/<organization_id>/
+        Update the organization details for the given id.
+
+    PATCH /api/organizations/<organization_id>/
+        Partially update the organization details for the given id.
+    """
+
+    permission_classes = [permissions.AccessPermission]
+    queryset = models.Organization.objects.all()
+    serializer_class = serializers.OrganizationSerializer
+    throttle_classes = [BurstRateThrottle, SustainedRateThrottle]
+
+    def get_queryset(self):
+        """Limit listed organizations to the one the user belongs to."""
+        return (
+            super()
+            .get_queryset()
+            .filter(pk=self.request.user.organization_id)
+            .annotate(
+                user_role=Subquery(
+                    models.OrganizationAccess.objects.filter(
+                        user=self.request.user, organization=OuterRef("pk")
+                    ).values("role")[:1]
+                )
+            )
+        )
+
+
 class UserViewSet(
-    mixins.UpdateModelMixin, viewsets.GenericViewSet, mixins.ListModelMixin
+    SerializerPerActionMixin,
+    mixins.UpdateModelMixin,
+    viewsets.GenericViewSet,
+    mixins.ListModelMixin,
 ):
     """
     User viewset for all interactions with user infos and teams.
 
     GET /api/users/&q=query
-        Return a list of users whose email matches the query. Similarity is
-        calculated using trigram similarity, allowing for partial,
-        case-insensitive matches and accented queries.
+        Return a list of users whose email or name matches the query.
     """
 
     permission_classes = [permissions.IsSelf]
-    queryset = models.User.objects.all().order_by("-created_at")
+    queryset = (
+        models.User.objects.select_related("organization").all().order_by("-created_at")
+    )
     serializer_class = serializers.UserSerializer
+    get_me_serializer_class = serializers.UserMeSerializer
     throttle_classes = [BurstRateThrottle, SustainedRateThrottle]
     pagination_class = Pagination
 
@@ -207,22 +247,11 @@ class UserViewSet(
             if team_id := self.request.GET.get("team_id", ""):
                 queryset = queryset.exclude(teams__id=team_id)
 
-            # Search by case-insensitive and accent-insensitive trigram similarity
+            # Search by case-insensitive and accent-insensitive
             if query := self.request.GET.get("q", ""):
-                similarity = Max(
-                    TrigramSimilarity(
-                        Coalesce(Func("email", function="unaccent"), Value("")),
-                        Func(Value(query), function="unaccent"),
-                    )
-                    + TrigramSimilarity(
-                        Coalesce(Func("name", function="unaccent"), Value("")),
-                        Func(Value(query), function="unaccent"),
-                    )
-                )
-                queryset = (
-                    queryset.annotate(similarity=similarity)
-                    .filter(similarity__gte=SIMILARITY_THRESHOLD)
-                    .order_by("-similarity")
+                queryset = queryset.filter(
+                    Q(name__unaccent__icontains=query)
+                    | Q(email__unaccent__icontains=query)
                 )
 
         return queryset
@@ -238,9 +267,7 @@ class UserViewSet(
         Return information on currently logged user
         """
         user = request.user
-        return response.Response(
-            self.serializer_class(user, context={"request": request}).data
-        )
+        return response.Response(self.get_serializer(user).data)
 
 
 class TeamViewSet(
@@ -259,14 +286,20 @@ class TeamViewSet(
     ordering_fields = ["created_at"]
     ordering = ["-created_at"]
     queryset = models.Team.objects.all()
+    pagination_class = None
 
     def get_queryset(self):
         """Custom queryset to get user related teams."""
         user_role_query = models.TeamAccess.objects.filter(
             user=self.request.user, team=OuterRef("pk")
         ).values("role")[:1]
-        return models.Team.objects.filter(accesses__user=self.request.user).annotate(
-            user_role=Subquery(user_role_query)
+
+        return (
+            models.Team.objects.prefetch_related("accesses", "service_providers")
+            .filter(
+                accesses__user=self.request.user,
+            )
+            .annotate(user_role=Subquery(user_role_query))
         )
 
     def perform_create(self, serializer):
@@ -340,6 +373,7 @@ class TeamAccessViewSet(
         return context
 
     def get_serializer_class(self):
+        """Chooses list or detail serializer according to the action."""
         if self.action in {"list", "retrieve"}:
             return self.list_serializer_class
         return self.detail_serializer_class
@@ -351,20 +385,9 @@ class TeamAccessViewSet(
 
         if self.action in {"list", "retrieve"}:
             if query := self.request.GET.get("q", ""):
-                similarity = Max(
-                    TrigramSimilarity(
-                        Coalesce(Func("user__email", function="unaccent"), Value("")),
-                        Func(Value(query), function="unaccent"),
-                    )
-                    + TrigramSimilarity(
-                        Coalesce(Func("user__name", function="unaccent"), Value("")),
-                        Func(Value(query), function="unaccent"),
-                    )
-                )
-                queryset = (
-                    queryset.annotate(similarity=similarity)
-                    .filter(similarity__gte=SIMILARITY_THRESHOLD)
-                    .order_by("-similarity")
+                queryset = queryset.filter(
+                    Q(user__email__unaccent__icontains=query)
+                    | Q(user__name__unaccent__icontains=query)
                 )
 
             # Determine which role the logged-in user has in the team
@@ -506,9 +529,56 @@ class ConfigView(views.APIView):
         GET /api/v1.0/config/
             Return a dictionary of public settings.
         """
-        array_settings = ["LANGUAGES", "FEATURES", "RELEASE"]
+        array_settings = ["LANGUAGES", "FEATURES", "RELEASE", "COMMIT"]
         dict_settings = {}
         for setting in array_settings:
             dict_settings[setting] = getattr(settings, setting)
 
         return response.Response(dict_settings)
+
+
+class ServiceProviderFilter(filters.BaseFilterBackend):
+    """
+    Filter service providers.
+    """
+
+    def filter_queryset(self, request, queryset, view):
+        """
+        Filter service providers by audience or name.
+        """
+        if name := request.GET.get("name"):
+            queryset = queryset.filter(name__icontains=name)
+        if audience_id := request.GET.get("audience_id"):
+            queryset = queryset.filter(audience_id=audience_id)
+        return queryset
+
+
+class ServiceProviderViewSet(
+    mixins.ListModelMixin,
+    mixins.RetrieveModelMixin,
+    viewsets.GenericViewSet,
+):
+    """
+    API ViewSet for all interactions with service providers.
+
+    GET /api/v1.0/service-providers/
+        Return a list of service providers.
+
+    GET /api/v1.0/service-providers/<service_provider_id>/
+        Return a service provider.
+    """
+
+    permission_classes = [permissions.IsAuthenticated]
+    queryset = models.ServiceProvider.objects.all()
+    serializer_class = serializers.ServiceProviderSerializer
+    throttle_classes = [BurstRateThrottle, SustainedRateThrottle]
+    pagination_class = Pagination
+    filter_backends = [filters.OrderingFilter, ServiceProviderFilter]
+    ordering = ["name"]
+    ordering_fields = ["name", "created_at"]
+
+    def get_queryset(self):
+        """Filter the queryset to limit results to user's organization."""
+        queryset = super().get_queryset()
+        queryset = queryset.filter(organizations__id=self.request.user.organization_id)
+        return queryset

src/backend/core/api/permissions.py

@@ -12,13 +12,13 @@ class IsAuthenticated(permissions.BasePermission):
     """
 
     def has_permission(self, request, view):
+        """Check auth token first."""
         return bool(request.auth) if request.auth else request.user.is_authenticated
 
 
 class IsSelf(IsAuthenticated):
     """
-    Allows access only to authenticated users. Alternative method checking the presence
-    of the auth token to avoid hitting the database.
+    Allows access only to user's own data.
     """
 
     def has_object_permission(self, request, view, obj):

src/backend/core/api/resource_server/__init__.py

@@ -0,0 +1 @@
+"""People core resource server API endpoints"""

src/backend/core/api/resource_server/serializers.py

@@ -0,0 +1,46 @@
+"""Client serializers for the People core app resource server API."""
+
+from rest_framework import serializers
+
+from core import models
+
+
+class TeamSerializer(serializers.ModelSerializer):
+    """Serialize teams."""
+
+    class Meta:
+        model = models.Team
+        fields = [
+            "id",
+            "name",
+            "created_at",
+            "updated_at",
+        ]
+        read_only_fields = [
+            "id",
+            "created_at",
+            "updated_at",
+        ]
+
+    def create(self, validated_data):
+        """
+        Create a new team with organization enforcement.
+
+        In this context, called as a resource server,
+        the team service provider is enforced.
+
+        When the service provider audience is unknown it is created on the fly.
+        """
+        sp_audience = self.context["from_service_provider_audience"]
+        service_provider, _created = models.ServiceProvider.objects.get_or_create(
+            audience_id=sp_audience
+        )
+
+        # Note: this is not the purpose of this API to check the user has an organization
+        return super().create(
+            validated_data=validated_data
+            | {
+                "organization_id": self.context["request"].user.organization_id,
+                "service_providers": [service_provider],
+            },
+        )

src/backend/core/api/resource_server/viewsets.py

@@ -0,0 +1,90 @@
+"""Resource server API endpoints"""
+
+from django.db.models import OuterRef, Prefetch, Subquery
+
+from rest_framework import (
+    filters,
+    mixins,
+    viewsets,
+)
+
+from core import models
+from core.api import permissions
+from core.api.client.viewsets import Pagination
+from core.resource_server.mixins import ResourceServerMixin
+
+from . import serializers
+
+
+class TeamViewSet(  # pylint: disable=too-many-ancestors
+    ResourceServerMixin,
+    mixins.CreateModelMixin,
+    mixins.ListModelMixin,
+    mixins.RetrieveModelMixin,
+    mixins.UpdateModelMixin,
+    viewsets.GenericViewSet,
+):
+    """
+    Team ViewSet dedicated to the resource server.
+
+    The DELETE method is not allowed for now, because the use case is
+    not clear yet and it comes with complexity to know if we can delete
+    a team or not (eg. if a team has other SP, it might not be deleted
+    but what do we do then, only remove the current SP?).
+
+    GET /resource-server/v1.0/teams/
+        Return list of Teams of the user and available for the audience.
+
+    POST /resource-server/v1.0/teams/
+        Create a new Team for the user for the audience.
+
+    GET /resource-server/v1.0/teams/{team_id}/
+        Return the Team details if available for the audience.
+
+    PUT /resource-server/v1.0/teams/{team_id}/
+        Update the Team details (only name for now).
+
+    """
+
+    permission_classes = [permissions.AccessPermission]
+    serializer_class = serializers.TeamSerializer
+    filter_backends = [filters.OrderingFilter]
+    ordering_fields = ["created_at"]
+    ordering = ["-created_at"]
+    queryset = models.Team.objects.all()
+    pagination_class = Pagination
+
+    def get_queryset(self):
+        """Custom queryset to get user related teams."""
+        user_role_query = models.TeamAccess.objects.filter(
+            user=self.request.user, team=OuterRef("pk")
+        ).values("role")[:1]
+
+        service_provider_audience = self._get_service_provider_audience()
+        service_provider_prefetch = Prefetch(
+            "service_providers",
+            queryset=models.ServiceProvider.objects.filter(
+                audience_id=service_provider_audience
+            ),
+        )
+
+        return (
+            models.Team.objects.prefetch_related(
+                "accesses",
+                service_provider_prefetch,
+            )
+            .filter(
+                accesses__user=self.request.user,
+                service_providers__audience_id=service_provider_audience,
+            )
+            .annotate(user_role=Subquery(user_role_query))
+        )
+
+    def perform_create(self, serializer):
+        """Set the current user as owner of the newly created team."""
+        team = serializer.save()
+        models.TeamAccess.objects.create(
+            team=team,
+            user=self.request.user,
+            role=models.RoleChoices.OWNER,
+        )

src/backend/core/authentication/__init__.py

@@ -0,0 +1 @@
+"""Authentication module."""

src/backend/core/authentication/backends.py

@@ -1,5 +1,9 @@
 """Authentication Backends for the People core app."""
 
+import logging
+from email.headerregistry import Address
+from typing import Optional
+
 from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.core.exceptions import SuspiciousOperation
@@ -10,9 +14,21 @@ from mozilla_django_oidc.auth import (
     OIDCAuthenticationBackend as MozillaOIDCAuthenticationBackend,
 )
 
+from core.models import Organization, OrganizationAccess, OrganizationRoleChoices
+
+logger = logging.getLogger(__name__)
+
 User = get_user_model()
 
 
+def get_domain_from_email(email: Optional[str]) -> Optional[str]:
+    """Extract domain from email."""
+    try:
+        return Address(addr_spec=email).domain
+    except (ValueError, AttributeError):
+        return None
+
+
 class OIDCAuthenticationBackend(MozillaOIDCAuthenticationBackend):
     """Custom OpenID Connect (OIDC) Authentication Backend.
 
@@ -67,19 +83,24 @@ class OIDCAuthenticationBackend(MozillaOIDCAuthenticationBackend):
 
         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")
+            )
+
         # Get user's full name from OIDC fields defined in settings
         full_name = self.compute_full_name(user_info)
         email = user_info.get("email")
 
         claims = {
+            "sub": sub,
             "email": email,
             "name": full_name,
         }
-
-        sub = user_info.get("sub")
-        if not sub:
-            raise SuspiciousOperation(
-                _("User info contained no recognizable user identification")
+        if settings.OIDC_ORGANIZATION_REGISTRATION_ID_FIELD:
+            claims[settings.OIDC_ORGANIZATION_REGISTRATION_ID_FIELD] = user_info.get(
+                settings.OIDC_ORGANIZATION_REGISTRATION_ID_FIELD
             )
 
         # if sub is absent, try matching on email
@@ -90,7 +111,41 @@ class OIDCAuthenticationBackend(MozillaOIDCAuthenticationBackend):
                 raise SuspiciousOperation(_("User account is disabled"))
             self.update_user_if_needed(user, claims)
         elif self.get_settings("OIDC_CREATE_USER", True):
-            user = User.objects.create(sub=sub, password="!", **claims)  # noqa: S106
+            user = self.create_user(claims)
+
+        # Data cleaning, to be removed when user organization is null=False
+        # or all users have an organization.
+        # See https://github.com/numerique-gouv/people/issues/504
+        if not user.organization_id:
+            organization_registration_id = claims.get(
+                settings.OIDC_ORGANIZATION_REGISTRATION_ID_FIELD
+            )
+            domain = get_domain_from_email(email)
+            try:
+                organization, organization_created = (
+                    Organization.objects.get_or_create_from_user_claims(
+                        registration_id=organization_registration_id,
+                        domain=domain,
+                    )
+                )
+                if organization_created:
+                    logger.info("Organization %s created", organization)
+                    # For this case, we don't create an OrganizationAccess we will
+                    # manage this manually later, because we don't want the first
+                    # user who log in after the release to be the admin of their
+                    # organization. We will keep organization without admin, and
+                    # we will have to manually clean things up (while there is
+                    # not that much organization in the database).
+            except ValueError as exc:
+                # Raised when there is no recognizable organization
+                # identifier (domain or registration_id)
+                logger.warning("Unable to update user organization: %s", exc)
+            else:
+                user.organization = organization
+                user.save()
+                logger.info(
+                    "User %s updated with organization %s", user.pk, organization
+                )
 
         return user
 
@@ -101,13 +156,47 @@ class OIDCAuthenticationBackend(MozillaOIDCAuthenticationBackend):
             raise SuspiciousOperation(
                 _("Claims contained no recognizable user identification")
             )
+        email = claims.get("email")
+        name = claims.get("name")
 
-        return self.UserModel.objects.create(
+        # Extract or create the organization from the data
+        organization_registration_id = claims.get(
+            settings.OIDC_ORGANIZATION_REGISTRATION_ID_FIELD
+        )
+        domain = get_domain_from_email(email)
+        try:
+            organization, organization_created = (
+                Organization.objects.get_or_create_from_user_claims(
+                    registration_id=organization_registration_id,
+                    domain=domain,
+                )
+            )
+        except ValueError as exc:
+            raise SuspiciousOperation(
+                _("Claims contained no recognizable organization identification")
+            ) from exc
+
+        if organization_created:
+            logger.info("Organization %s created", organization)
+
+        logger.info("Creating user %s / %s", sub, email)
+
+        user = self.UserModel.objects.create(
+            organization=organization,
             password="!",  # noqa: S106
             sub=sub,
-            email=claims.get("email"),
-            name=claims.get("name"),
+            email=email,
+            name=name,
         )
+        if organization_created:
+            # Warning: we may remove this behavior in the near future when we
+            # add a feature to claim the organization ownership.
+            OrganizationAccess.objects.create(
+                organization=organization,
+                user=user,
+                role=OrganizationRoleChoices.ADMIN,
+            )
+        return user
 
     def compute_full_name(self, user_info):
         """Compute user's full name based on OIDC fields in settings."""
@@ -131,9 +220,11 @@ class OIDCAuthenticationBackend(MozillaOIDCAuthenticationBackend):
 
     def update_user_if_needed(self, user, claims):
         """Update user claims if they have changed."""
-        has_changed = any(
-            value and value != getattr(user, key) for key, value in claims.items()
-        )
-        if has_changed:
-            updated_claims = {key: value for key, value in claims.items() if value}
+        updated_claims = {}
+        for key in ["email", "name"]:
+            claim_value = claims.get(key)
+            if claim_value and claim_value != getattr(user, key):
+                updated_claims[key] = claim_value
+
+        if updated_claims:
             self.UserModel.objects.filter(sub=user.sub).update(**updated_claims)

src/backend/core/factories.py

@@ -119,6 +119,41 @@ class ContactFactory(BaseContactFactory):
     owner = factory.SubFactory("core.factories.UserFactory", profile_contact=None)
 
 
+class OrganizationFactory(factory.django.DjangoModelFactory):
+    """Factory to create organizations for testing purposes."""
+
+    name = factory.Faker("company")
+
+    class Meta:
+        model = models.Organization
+
+    class Params:  # pylint: disable=missing-class-docstring
+        with_registration_id = factory.Trait(
+            registration_id_list=factory.List(
+                [factory.Sequence(lambda n: f"{n:014d}")]
+            ),
+        )
+        with_domain = factory.Trait(
+            domain_list=factory.List([factory.Faker("domain_name")]),
+        )
+
+
+class OrganizationAccessFactory(factory.django.DjangoModelFactory):
+    """Factory to create organization accesses for testing purposes."""
+
+    class Meta:
+        model = models.OrganizationAccess
+
+    user = factory.SubFactory(
+        "core.factories.UserFactory",
+        organization=factory.SelfAttribute("..organization"),
+    )
+    organization = factory.SubFactory(
+        "core.factories.OrganizationFactory", with_registration_id=True
+    )
+    role = factory.fuzzy.FuzzyChoice(models.OrganizationRoleChoices.values)
+
+
 class UserFactory(factory.django.DjangoModelFactory):
     """A factory to create random users for testing purposes."""
 
@@ -126,6 +161,13 @@ class UserFactory(factory.django.DjangoModelFactory):
         model = models.User
         django_get_or_create = ("sub",)
 
+    class Params:
+        with_organization = factory.Trait(
+            organization=factory.SubFactory(
+                OrganizationFactory, with_registration_id=True
+            ),
+        )
+
     sub = factory.Sequence(lambda n: f"user{n!s}")
     email = factory.Faker("email")
     name = factory.Faker("name")
@@ -154,6 +196,13 @@ class TeamFactory(factory.django.DjangoModelFactory):
             else:
                 TeamAccessFactory(team=self, user=user_entry[0], role=user_entry[1])
 
+    @factory.post_generation
+    def service_providers(self, create, extracted, **kwargs):
+        """Add service providers to team from a given list of service providers."""
+        if not create or not extracted:
+            return
+        self.service_providers.set(extracted)
+
 
 class TeamAccessFactory(factory.django.DjangoModelFactory):
     """Create fake team user accesses for testing."""
@@ -186,3 +235,27 @@ class InvitationFactory(factory.django.DjangoModelFactory):
     email = factory.Faker("email")
     role = factory.fuzzy.FuzzyChoice([role[0] for role in models.RoleChoices.choices])
     issuer = factory.SubFactory(UserFactory)
+
+
+class ServiceProviderFactory(factory.django.DjangoModelFactory):
+    """A factory to create service providers for testing purposes."""
+
+    class Meta:
+        model = models.ServiceProvider
+        skip_postgeneration_save = True
+
+    audience_id = factory.Faker("uuid4")
+
+    @factory.post_generation
+    def teams(self, create, extracted, **kwargs):
+        """Add teams to service provider from a given list."""
+        if not create or not extracted:
+            return
+        self.teams.set(extracted)
+
+    @factory.post_generation
+    def organizations(self, create, extracted, **kwargs):
+        """Add organization to service provider from a given list."""
+        if not create or not extracted:
+            return
+        self.organizations.set(extracted)

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

@@ -0,0 +1,62 @@
+# Generated by Django 5.1.1 on 2024-10-22 10:07
+
+import core.models
+import django.contrib.postgres.fields
+import django.db.models.deletion
+import uuid
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('core', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Organization',
+            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 at')),
+                ('updated_at', models.DateTimeField(auto_now=True, help_text='date and time at which a record was last updated', verbose_name='updated at')),
+                ('name', models.CharField(max_length=100, verbose_name='name')),
+                ('registration_id_list', django.contrib.postgres.fields.ArrayField(base_field=models.CharField(max_length=128), blank=True, default=list, size=None, verbose_name='registration ID list')),
+                ('domain_list', django.contrib.postgres.fields.ArrayField(base_field=models.CharField(max_length=256), blank=True, default=list, size=None, verbose_name='domain list')),
+            ],
+            options={
+                'verbose_name': 'organization',
+                'verbose_name_plural': 'organizations',
+                'db_table': 'people_organization',
+                'constraints': [models.CheckConstraint(condition=models.Q(('registration_id_list__len__gt', 0), ('domain_list__len__gt', 0), _connector='OR'), name='registration_id_or_domain', violation_error_message='An organization must have at least a registration ID or a domain.')],
+            },
+        ),
+        migrations.AddField(
+            model_name='team',
+            name='organization',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.PROTECT, related_name='teams', to='core.organization'),
+        ),
+        migrations.AddField(
+            model_name='user',
+            name='organization',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.PROTECT, related_name='users', to='core.organization'),
+        ),
+        migrations.CreateModel(
+            name='OrganizationAccess',
+            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 at')),
+                ('updated_at', models.DateTimeField(auto_now=True, help_text='date and time at which a record was last updated', verbose_name='updated at')),
+                ('role', models.CharField(choices=[('administrator', 'Administrator')], default='administrator', max_length=20)),
+                ('organization', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='organization_accesses', to='core.organization')),
+                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='organization_accesses', to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'verbose_name': 'Organization/user relation',
+                'verbose_name_plural': 'Organization/user relations',
+                'db_table': 'people_organization_access',
+                'constraints': [models.UniqueConstraint(fields=('user', 'organization'), name='unique_organization_user', violation_error_message='This user is already in this organization.')],
+            },
+        ),
+    ]

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

@@ -0,0 +1,18 @@
+# Generated by Django 5.1.2 on 2024-11-04 14:25
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('core', '0002_add_organization_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='team',
+            name='slug',
+            field=models.SlugField(max_length=100, null=True),
+        ),
+    ]

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

@@ -0,0 +1,17 @@
+# Generated by Django 5.1.3 on 2024-11-20 10:08
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('core', '0003_team_slug_nullable'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='team',
+            name='slug',
+        ),
+    ]

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

@@ -0,0 +1,39 @@
+# Generated by Django 5.1.2 on 2024-11-07 16:24
+
+import uuid
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('core', '0004_remove_team_slug'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='ServiceProvider',
+            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 at')),
+                ('updated_at', models.DateTimeField(auto_now=True, help_text='date and time at which a record was last updated', verbose_name='updated at')),
+                ('name', models.CharField(max_length=256, unique=True, verbose_name='name')),
+                ('audience_id', models.CharField(db_index=True, max_length=256, unique=True, verbose_name='audience id')),
+            ],
+            options={
+                'verbose_name': 'service provider',
+                'verbose_name_plural': 'service providers',
+                'db_table': 'people_service_provider',
+            },
+        ),
+        migrations.AddField(
+            model_name='organization',
+            name='service_providers',
+            field=models.ManyToManyField(blank=True, related_name='organizations', to='core.serviceprovider'),
+        ),
+        migrations.AddField(
+            model_name='team',
+            name='service_providers',
+            field=models.ManyToManyField(blank=True, related_name='teams', to='core.serviceprovider'),
+        ),
+    ]

src/backend/core/models.py

@@ -6,19 +6,22 @@ import json
 import os
 import smtplib
 import uuid
+from contextlib import suppress
 from datetime import timedelta
 from logging import getLogger
+from typing import Tuple
 
 from django.conf import settings
 from django.contrib.auth import models as auth_models
 from django.contrib.auth.base_user import AbstractBaseUser
+from django.contrib.postgres.fields import ArrayField
 from django.contrib.sites.models import Site
 from django.core import exceptions, mail, validators
+from django.core.exceptions import ValidationError
 from django.db import models, transaction
 from django.template.loader import render_to_string
 from django.utils import timezone
 from django.utils.functional import lazy
-from django.utils.text import slugify
 from django.utils.translation import gettext_lazy as _
 from django.utils.translation import override
 
@@ -27,6 +30,7 @@ from timezone_field import TimeZoneField
 
 from core.enums import WebhookStatusChoices
 from core.utils.webhooks import scim_synchronizer
+from core.validators import get_field_validators_from_setting
 
 logger = getLogger(__name__)
 
@@ -36,7 +40,7 @@ with open(contact_schema_path, "r", encoding="utf-8") as contact_schema_file:
     contact_schema = json.load(contact_schema_file)
 
 
-class RoleChoices(models.TextChoices):
+class RoleChoices(models.TextChoices):  # pylint: disable=too-many-ancestors
     """Defines the possible roles a user can have in a team."""
 
     MEMBER = "member", _("Member")
@@ -44,6 +48,17 @@ class RoleChoices(models.TextChoices):
     OWNER = "owner", _("Owner")
 
 
+class OrganizationRoleChoices(models.TextChoices):  # pylint: disable=too-many-ancestors
+    """
+    Defines the possible roles a user can have in an organization.
+    For now, we only have one role, but we might add more in the future.
+
+    administrator: The user can manage the organization: change name, add/remove users.
+    """
+
+    ADMIN = "administrator", _("Administrator")
+
+
 class BaseModel(models.Model):
     """
     Serves as an abstract base model for other models, ensuring that records are validated
@@ -158,6 +173,203 @@ class Contact(BaseModel):
             raise exceptions.ValidationError({"data": [error_message]}) from e
 
 
+class ServiceProvider(BaseModel):
+    """
+    Represents a service provider that will consume our information.
+
+    Organization uses this model to define the list of SP available to their users.
+    Team uses this model to define their visibility to the various SP.
+    """
+
+    name = models.CharField(_("name"), max_length=256, unique=True)
+    audience_id = models.CharField(
+        _("audience id"), max_length=256, unique=True, db_index=True
+    )
+
+    class Meta:
+        db_table = "people_service_provider"
+        verbose_name = _("service provider")
+        verbose_name_plural = _("service providers")
+
+    def __str__(self):
+        return self.name
+
+    def save(self, *args, **kwargs):
+        """Enforce name (even if ugly) from the `audience_id` field."""
+        if not self.name:
+            self.name = self.audience_id  # ok, same length
+        return super().save(*args, **kwargs)
+
+
+class OrganizationManager(models.Manager):
+    """
+    Custom manager for the Organization model, to manage complexity/automation.
+    """
+
+    def get_or_create_from_user_claims(
+        self, registration_id: str = None, domain: str = None, **kwargs
+    ) -> Tuple["Organization", bool]:
+        """
+        Get or create an organization using the most fitting information from the user's claims.
+
+        We expect to have only one organization per registration_id, but
+        the registration_id might not be provided.
+        When the registration_id is not provided, we use the domain to identify the organization.
+
+        If both are provided, we use the registration_id first to create missing organization.
+
+        Dev note: When a registration_id is provided by the Identity Provider, we don't want
+        to use the domain to create the organization, because it is less reliable: for example,
+        a professional user, may have a personal email address, and the domain would be gmail.com
+        which is not a good identifier for an organization. The domain email is just a fallback
+        when the registration_id is not provided by the Identity Provider. We can use the domain
+        to create the organization manually when we are sure about the "safety" of it.
+        """
+        if not any([registration_id, domain]):
+            raise ValueError("You must provide either a registration_id or a domain.")
+
+        filters = models.Q()
+        if registration_id:
+            filters |= models.Q(registration_id_list__icontains=registration_id)
+        if domain:
+            filters |= models.Q(domain_list__icontains=domain)
+
+        with suppress(self.model.DoesNotExist):
+            # If there are several organizations, we must raise an error and fix the data
+            # If there is an organization, we return it
+            return self.get(filters, **kwargs), False
+
+        # Manage the case where the organization does not exist: we create one
+        if registration_id:
+            return self.create(
+                name=registration_id, registration_id_list=[registration_id], **kwargs
+            ), True
+
+        if domain:
+            return self.create(name=domain, domain_list=[domain], **kwargs), True
+
+        raise ValueError("Should never reach this point.")
+
+
+class Organization(BaseModel):
+    """
+    Organization model used to regroup Teams.
+
+    Each User have an Organization, which corresponds actually to a default organization
+    because a user can belong to a Team from another organization.
+    Each Team have an Organization, which is the Organization from the User who created
+    the Team.
+
+    Organization is managed automatically, the User should never choose their Organization.
+    When creating a User, you must use the `get_or_create` method from the
+    OrganizationManager to find the proper Organization.
+
+    An Organization can have several registration IDs and domains but during automatic
+    creation process, only one will be used. We may want to allow (manual) organization merge
+    later, to regroup several registration IDs or domain in the same Organization.
+    """
+
+    name = models.CharField(_("name"), max_length=100)
+    registration_id_list = ArrayField(
+        models.CharField(
+            max_length=128,
+            validators=get_field_validators_from_setting(
+                "ORGANIZATION_REGISTRATION_ID_VALIDATORS"
+            ),
+        ),
+        verbose_name=_("registration ID list"),
+        default=list,
+        blank=True,
+        # list overlap validation is done in the validate_unique method
+    )
+    domain_list = ArrayField(
+        models.CharField(max_length=256),
+        verbose_name=_("domain list"),
+        default=list,
+        blank=True,
+        # list overlap validation is done in the validate_unique method
+    )
+
+    service_providers = models.ManyToManyField(
+        ServiceProvider,
+        related_name="organizations",
+        blank=True,
+    )
+
+    objects = OrganizationManager()
+
+    class Meta:
+        db_table = "people_organization"
+        verbose_name = _("organization")
+        verbose_name_plural = _("organizations")
+        constraints = [
+            models.CheckConstraint(
+                name="registration_id_or_domain",
+                condition=models.Q(registration_id_list__len__gt=0)
+                | models.Q(domain_list__len__gt=0),
+                violation_error_message=_(
+                    "An organization must have at least a registration ID or a domain."
+                ),
+            ),
+            # Check a registration ID str can only be present in one
+            # organization registration ID list
+            # Check a domain str can only be present in one organization domain list
+            # Those checks cannot be done with Django constraints
+        ]
+
+    def __str__(self):
+        return f"{self.name} (# {self.pk})"
+
+    def validate_unique(self, exclude=None):
+        """
+        Validate Registration/Domain values in an array field are unique
+        across all instances.
+
+        This can't be done in the field validator because we need to
+        exclude the current object if already in database.
+        """
+        super().validate_unique(exclude=exclude)
+
+        if self.pk:
+            organization_qs = Organization.objects.exclude(pk=self.pk)
+        else:
+            organization_qs = Organization.objects.all()
+
+        # Check a registration ID can only be present in one organization
+        if (
+            self.registration_id_list
+            and organization_qs.filter(
+                registration_id_list__overlap=self.registration_id_list
+            ).exists()
+        ):
+            raise ValidationError(
+                "registration_id_list value must be unique across all instances."
+            )
+
+        # Check a domain can only be present in one organization
+        if (
+            self.domain_list
+            and organization_qs.filter(domain_list__overlap=self.domain_list).exists()
+        ):
+            raise ValidationError(
+                "domain_list value must be unique across all instances."
+            )
+
+    def get_abilities(self, user):
+        """
+        Compute and return abilities for a given user on the organization.
+        """
+        # Use the role from queryset annotation will raise on purpose if not used properly
+        is_admin = self.user_role == OrganizationRoleChoices.ADMIN  # pylint: disable=no-member
+
+        return {
+            "get": user.organization_id == self.pk,
+            "patch": is_admin,
+            "put": is_admin,
+            "delete": False,
+        }
+
+
 class User(AbstractBaseUser, BaseModel, auth_models.PermissionsMixin):
     """User model to work with OIDC only authentication."""
 
@@ -218,6 +430,13 @@ class User(AbstractBaseUser, BaseModel, auth_models.PermissionsMixin):
             "Unselect this instead of deleting accounts."
         ),
     )
+    organization = models.ForeignKey(
+        Organization,
+        on_delete=models.PROTECT,
+        related_name="users",
+        null=True,  # Need to be set to False when everything is migrated
+        blank=True,  # Need to be set to False when everything is migrated
+    )
 
     objects = auth_models.UserManager()
 
@@ -284,14 +503,113 @@ class User(AbstractBaseUser, BaseModel, auth_models.PermissionsMixin):
             raise ValueError("You must first set an email for the user.")
         mail.send_mail(subject, message, from_email, [self.email], **kwargs)
 
+    def get_abilities(self):
+        """
+        Return the user permissions at the application level (ie feature availability).
+
+        Note: this is for display purposes only for now.
+
+        - Contacts view and creation is globally available (or not) for now.
+        - Teams view is available if the user is owner or admin of at least
+        one Team for now. It allows to restrict users knowing the existence of
+        this feature.
+        - Teams creation is globally available (or not) for now.
+        - Mailboxes view is available if the user has access to at least one
+        MailDomain for now. It allows to restrict users knowing the existence of
+        this feature.
+        - Mailboxes creation is globally available (or not) for now.
+        """
+        user_info = (
+            self._meta.model.objects.filter(pk=self.pk)
+            .annotate(
+                teams_can_view=models.Exists(
+                    self.accesses.model.objects.filter(  # pylint: disable=no-member
+                        user=models.OuterRef("pk"),
+                        role__in=[RoleChoices.OWNER, RoleChoices.ADMIN],
+                    )
+                ),
+                mailboxes_can_view=models.Exists(
+                    self.mail_domain_accesses.model.objects.filter(  # pylint: disable=no-member
+                        user=models.OuterRef("pk")
+                    )
+                ),
+            )
+            .only("id")
+            .get()
+        )
+
+        teams_can_view = user_info.teams_can_view
+        mailboxes_can_view = user_info.mailboxes_can_view
+
+        return {
+            "contacts": {
+                "can_view": settings.FEATURES["CONTACTS_DISPLAY"],
+                "can_create": (
+                    settings.FEATURES["CONTACTS_DISPLAY"]
+                    and settings.FEATURES["CONTACTS_CREATE"]
+                ),
+            },
+            "teams": {
+                "can_view": teams_can_view and settings.FEATURES["TEAMS_DISPLAY"],
+                "can_create": teams_can_view and settings.FEATURES["TEAMS_CREATE"],
+            },
+            "mailboxes": {
+                "can_view": mailboxes_can_view,
+                "can_create": mailboxes_can_view
+                and settings.FEATURES["MAILBOXES_CREATE"],
+            },
+        }
+
+
+class OrganizationAccess(BaseModel):
+    """
+    Link table between organization and users,
+    only for user with specific rights on Organization.
+    """
+
+    organization = models.ForeignKey(
+        Organization,
+        on_delete=models.CASCADE,
+        related_name="organization_accesses",
+    )
+    user = models.ForeignKey(
+        User,
+        on_delete=models.CASCADE,
+        related_name="organization_accesses",
+    )
+    role = models.CharField(
+        max_length=20,
+        choices=OrganizationRoleChoices.choices,
+        default=OrganizationRoleChoices.ADMIN,
+    )
+
+    class Meta:
+        db_table = "people_organization_access"
+        verbose_name = _("Organization/user relation")
+        verbose_name_plural = _("Organization/user relations")
+        constraints = [
+            models.UniqueConstraint(
+                fields=["user", "organization"],
+                name="unique_organization_user",
+                violation_error_message=_("This user is already in this organization."),
+            ),
+        ]
+
+    def __str__(self):
+        return f"{self.user!s} is {self.role:s} in organization {self.organization!s}"
+
 
 class Team(BaseModel):
     """
     Represents the link between teams and users, specifying the role a user has in a team.
+
+    When a team is created from here, the user have to choose which Service Providers
+    can see it.
+    When a team is created from a Service Provider this one is automatically set in the
+    Team `service_providers`.
     """
 
     name = models.CharField(max_length=100)
-    slug = models.SlugField(max_length=100, unique=True, null=False, editable=False)
 
     users = models.ManyToManyField(
         User,
@@ -299,6 +617,18 @@ class Team(BaseModel):
         through_fields=("team", "user"),
         related_name="teams",
     )
+    organization = models.ForeignKey(
+        Organization,
+        on_delete=models.PROTECT,
+        related_name="teams",
+        null=True,  # Need to be set to False when everything is migrated
+        blank=True,  # Need to be set to False when everything is migrated
+    )
+    service_providers = models.ManyToManyField(
+        ServiceProvider,
+        related_name="teams",
+        blank=True,
+    )
 
     class Meta:
         db_table = "people_team"
@@ -309,15 +639,6 @@ class Team(BaseModel):
     def __str__(self):
         return self.name
 
-    def save(self, *args, **kwargs):
-        """Override save function to compute the slug."""
-        self.slug = self.get_slug()
-        return super().save(*args, **kwargs)
-
-    def get_slug(self):
-        """Compute slug value from name."""
-        return slugify(self.name)
-
     def get_abilities(self, user):
         """
         Compute and return abilities for a given user on the team.

src/backend/core/resource_server/__init__.py

@@ -0,0 +1 @@
+"""Backend resource server module."""

src/backend/core/resource_server/authentication.py

@@ -19,6 +19,7 @@ class ResourceServerAuthentication(OIDCAuthentication):
     """Authenticate clients using the token received from the authorization server."""
 
     def __init__(self):
+        """Require authentication to be configured in order to instantiate."""
         super().__init__()
 
         try:
@@ -40,7 +41,7 @@ class ResourceServerAuthentication(OIDCAuthentication):
     def get_access_token(self, request):
         """Retrieve and decode the access token from the request.
 
-        This method overcharges the 'get_access_token' method from the parent class,
+        This method overrides the 'get_access_token' method from the parent class,
         to support service providers that would base64 encode the bearer token.
         """
 
@@ -52,3 +53,20 @@ class ResourceServerAuthentication(OIDCAuthentication):
             pass
 
         return access_token
+
+    def authenticate(self, request):
+        """
+        Authenticate the request and return a tuple of (user, token) or None.
+
+        We override the 'authenticate' method from the parent class to store
+        the introspected token audience inside the request.
+        """
+        result = super().authenticate(request)  # Might raise AuthenticationFailed
+
+        if result is None:  # Case when there is no access token
+            return None
+
+        # Note: at this stage, the request is a "drf_request" object
+        request.resource_server_token_audience = self.backend.token_origin_audience
+
+        return result

src/backend/core/resource_server/backend.py

@@ -33,6 +33,7 @@ class ResourceServerBackend:
 
     # pylint: disable=too-many-instance-attributes
     def __init__(self, authorization_server_client):
+        """Require client_id, client_secret set and authorization_server_client provided."""
         # pylint: disable=invalid-name
         self.UserModel = auth.get_user_model()
 
@@ -60,6 +61,10 @@ class ResourceServerBackend:
             token_introspection={"essential": True},
         )
 
+        # Declare the token origin audience: to know where the token comes from
+        # and store it for further use in the application
+        self.token_origin_audience = None
+
     # pylint: disable=unused-argument
     def get_or_create_user(self, access_token, id_token, payload):
         """Maintain API compatibility with OIDCAuthentication class from mozilla-django-oidc
@@ -84,6 +89,8 @@ class ResourceServerBackend:
         that extends RFC 7662 by returning a signed and encrypted JWT for stronger assurance that
         the authorization server issued the token introspection response.
         """
+        self.token_origin_audience = None  # Reset the token origin audience
+
         jwt = self._introspect(access_token)
         claims = self._verify_claims(jwt)
         user_info = self._verify_user_info(claims["token_introspection"])
@@ -99,6 +106,8 @@ class ResourceServerBackend:
             logger.debug("Login failed: No user with %s found", sub)
             return None
 
+        self.token_origin_audience = str(user_info["aud"])
+
         return user
 
     def _verify_user_info(self, introspection_response):
@@ -126,6 +135,12 @@ class ResourceServerBackend:
             logger.debug(message)
             raise SuspiciousOperation(message)
 
+        audience = introspection_response.get("aud", None)
+        if not audience:
+            raise SuspiciousOperation(
+                "Introspection response does not provide source audience."
+            )
+
         return introspection_response
 
     def _introspect(self, token):
@@ -218,6 +233,8 @@ class ResourceServerBackend:
 class ResourceServerImproperlyConfiguredBackend:
     """Fallback backend for improperly configured Resource Servers."""
 
+    token_origin_audience = None
+
     def get_or_create_user(self, access_token, id_token, payload):
         """Indicate that the Resource Server is improperly configured."""
         raise AuthenticationFailed("Resource Server is improperly configured")

src/backend/core/resource_server/clients.py

@@ -19,7 +19,7 @@ class AuthorizationServerClient:
     - Setting appropriate headers for secure communication as recommended by RFC drafts.
     """
 
-    # ruff: noqa: PLR0913 PLR017
+    # ruff: noqa: PLR0913 PLR0917
     # pylint: disable=too-many-positional-arguments
     # pylint: disable=too-many-arguments
     def __init__(
@@ -31,6 +31,8 @@ class AuthorizationServerClient:
         timeout,
         proxy,
     ):
+        """Require at a minimum url, url_jwks and url_introspection."""
+
         if not url or not url_jwks or not url_introspection:
             raise ImproperlyConfigured(
                 "Could not instantiate AuthorizationServerClient, some parameters are missing."

src/backend/core/resource_server/mixins.py

@@ -0,0 +1,53 @@
+"""
+Mixins for resource server views.
+"""
+
+from rest_framework import exceptions as drf_exceptions
+
+from .authentication import ResourceServerAuthentication
+
+
+class ResourceServerMixin:
+    """
+    Mixin for resource server views:
+     - Restrict the authentication class to ResourceServerAuthentication.
+     - Adds the Service Provider ID to the serializer context.
+     - Fetch the Service Provider ID from the OIDC introspected token stored
+       in the request.
+
+    This Mixin *must* be used in every view that should act as a resource server.
+    """
+
+    authentication_classes = [ResourceServerAuthentication]
+
+    def get_serializer_context(self):
+        """Extra context provided to the serializer class."""
+        context = super().get_serializer_context()
+
+        # When used as a resource server, we need to know the audience to automatically:
+        # - add the Service Provider to the team "scope" on creation
+        context["from_service_provider_audience"] = (
+            self._get_service_provider_audience()
+        )
+
+        return context
+
+    def _get_service_provider_audience(self):
+        """Return the audience of the Service Provider from the OIDC introspected token."""
+        if not isinstance(
+            self.request.successful_authenticator, ResourceServerAuthentication
+        ):
+            # We could check request.resource_server_token_audience here, but it's
+            # more explicit to check the authenticator type and assert the attribute
+            # existence.
+            return None
+
+        # When used as a resource server, the request has a token audience
+        service_provider_audience = self.request.resource_server_token_audience
+
+        if not service_provider_audience:  # should not happen
+            raise drf_exceptions.AuthenticationFailed(
+                "Resource server token audience not found in request"
+            )
+
+        return service_provider_audience

src/backend/core/templatetags/__init__.py

@@ -0,0 +1 @@
+"""Core template tags module."""

src/backend/core/tests/__init__.py

@@ -0,0 +1 @@
+"""Core tests."""

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

@@ -0,0 +1 @@
+"""Core authentication tests."""

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

@@ -42,7 +42,8 @@ def test_authentication_getter_existing_user_with_email(
     When the user's info contains an email and targets an existing user,
     """
     klass = OIDCAuthenticationBackend()
-    user = factories.UserFactory(name="John Doe")
+
+    user = factories.UserFactory(name="John Doe", with_organization=True)
 
     def get_userinfo_mocked(*args):
         return {
@@ -79,7 +80,9 @@ def test_authentication_getter_existing_user_change_fields(
     It should update the email or name fields on the user when they change.
     """
     klass = OIDCAuthenticationBackend()
-    user = factories.UserFactory(name="John Doe", email="john.doe@example.com")
+    user = factories.UserFactory(
+        name="John Doe", email="john.doe@example.com", with_organization=True
+    )
 
     def get_userinfo_mocked(*args):
         return {
@@ -103,6 +106,39 @@ def test_authentication_getter_existing_user_change_fields(
     assert user.name == f"{first_name:s} {last_name:s}"
 
 
+def test_authentication_getter_existing_user_keep_fields(
+    django_assert_num_queries, monkeypatch
+):
+    """
+    Falsy values in claim should not update the user's fields.
+    """
+    klass = OIDCAuthenticationBackend()
+    user = factories.UserFactory(
+        name="John Doe", email="john.doe@example.com", with_organization=True
+    )
+
+    def get_userinfo_mocked(*args):
+        return {
+            "sub": user.sub,
+            "email": None,
+            "first_name": "",
+            "last_name": "",
+        }
+
+    monkeypatch.setattr(OIDCAuthenticationBackend, "get_userinfo", get_userinfo_mocked)
+
+    # No field changed no more query
+    with django_assert_num_queries(1):
+        authenticated_user = klass.get_or_create_user(
+            access_token="test-token", id_token=None, payload=None
+        )
+
+    assert user == authenticated_user
+    user.refresh_from_db()
+    assert user.email == "john.doe@example.com"
+    assert user.name == "John Doe"
+
+
 def test_authentication_getter_existing_user_via_email(
     django_assert_num_queries, monkeypatch
 ):
@@ -112,7 +148,7 @@ def test_authentication_getter_existing_user_via_email(
     """
 
     klass = OIDCAuthenticationBackend()
-    db_user = factories.UserFactory()
+    db_user = factories.UserFactory(with_organization=True)
 
     def get_userinfo_mocked(*args):
         return {"sub": "123", "email": db_user.email}
@@ -158,25 +194,23 @@ def test_authentication_getter_existing_user_no_fallback_to_email(
 
 def test_authentication_getter_new_user_no_email(monkeypatch):
     """
-    If no user matches the user's info sub, a user should be created.
-    User's info doesn't contain an email/name, created user's email/name should be empty.
+    If no user matches the user's info sub, a user should not be created without email
+    nor organization registration ID.
     """
     klass = OIDCAuthenticationBackend()
 
     def get_userinfo_mocked(*args):
-        return {"sub": "123"}
+        return {"sub": "123"}  # No email, no organization registration ID
 
     monkeypatch.setattr(OIDCAuthenticationBackend, "get_userinfo", get_userinfo_mocked)
 
-    user = klass.get_or_create_user(
-        access_token="test-token", id_token=None, payload=None
-    )
-
-    assert user.sub == "123"
-    assert user.email is None
-    assert user.name is None
-    assert user.password == "!"
-    assert models.User.objects.count() == 1
+    with (
+        pytest.raises(
+            SuspiciousOperation,
+            match="Claims contained no recognizable organization identification",
+        ),
+    ):
+        klass.get_or_create_user(access_token="test-token", id_token=None, payload=None)
 
 
 def test_authentication_getter_new_user_with_email(monkeypatch):
@@ -284,3 +318,138 @@ def test_authentication_getter_existing_disabled_user_via_email(
         klass.get_or_create_user(access_token="test-token", id_token=None, payload=None)
 
     assert models.User.objects.count() == 1
+
+
+def test_authentication_getter_new_user_with_email_new_organization(monkeypatch):
+    """
+    If no user matches the user's info sub, a user should be created.
+    If the corresponding organization doesn't exist, it should be created.
+    """
+    klass = OIDCAuthenticationBackend()
+    email = "people@example.com"
+
+    def get_userinfo_mocked(*args):
+        return {"sub": "123", "email": email, "first_name": "John", "last_name": "Doe"}
+
+    monkeypatch.setattr(OIDCAuthenticationBackend, "get_userinfo", get_userinfo_mocked)
+
+    user = klass.get_or_create_user(
+        access_token="test-token", id_token=None, payload=None
+    )
+
+    assert user.organization is not None
+    assert user.organization.domain_list == ["example.com"]
+    assert user.organization.registration_id_list == []
+
+
+@pytest.mark.parametrize(
+    "registration_id_setting,expected_registration_id_list,expected_domain_list",
+    [
+        (None, [], ["example.com"]),
+        ("missing-claim", [], ["example.com"]),
+        ("registration_number", ["12345678901234"], []),
+    ],
+)
+def test_authentication_getter_new_user_with_registration_id_new_organization(
+    monkeypatch,
+    settings,
+    registration_id_setting,
+    expected_registration_id_list,
+    expected_domain_list,
+):
+    """
+    If no user matches the user's info sub, a user should be created.
+    If the corresponding organization doesn't exist, it should be created.
+    """
+    settings.OIDC_ORGANIZATION_REGISTRATION_ID_FIELD = registration_id_setting
+
+    klass = OIDCAuthenticationBackend()
+    email = "people@example.com"
+
+    def get_userinfo_mocked(*args):
+        return {
+            "sub": "123",
+            "email": email,
+            "first_name": "John",
+            "last_name": "Doe",
+            "registration_number": "12345678901234",
+        }
+
+    monkeypatch.setattr(OIDCAuthenticationBackend, "get_userinfo", get_userinfo_mocked)
+
+    user = klass.get_or_create_user(
+        access_token="test-token", id_token=None, payload=None
+    )
+
+    assert user.organization is not None
+    assert user.organization.domain_list == expected_domain_list
+    assert user.organization.registration_id_list == expected_registration_id_list
+
+
+def test_authentication_getter_existing_user_via_email_update_organization(
+    django_assert_num_queries, monkeypatch
+):
+    """
+    If an existing user already exists without organization, the organization must be updated.
+    """
+
+    klass = OIDCAuthenticationBackend()
+    db_user = factories.UserFactory(name="John Doe", email="toto@my-domain.com")
+
+    def get_userinfo_mocked(*args):
+        return {
+            "sub": db_user.sub,
+            "email": db_user.email,
+            "first_name": "John",
+            "last_name": "Doe",
+        }
+
+    monkeypatch.setattr(OIDCAuthenticationBackend, "get_userinfo", get_userinfo_mocked)
+
+    with django_assert_num_queries(9):
+        user = klass.get_or_create_user(
+            access_token="test-token", id_token=None, payload=None
+        )
+
+    assert user == db_user
+    assert user.organization is not None
+    assert user.organization.domain_list == ["my-domain.com"]
+
+
+def test_authentication_getter_existing_user_with_registration_id(
+    monkeypatch,
+    settings,
+):
+    """
+    Authenticate a user who already exists with an organization registration ID.
+
+    This asserts the "update_user_if_needed" does not fail when the claim
+    contains the organization registration ID (or any value not present in the
+    User model).
+    """
+    settings.OIDC_ORGANIZATION_REGISTRATION_ID_FIELD = "registration_number"
+
+    klass = OIDCAuthenticationBackend()
+    _existing_user = factories.UserFactory(
+        sub="123",
+        name="John Doe",
+        email="people@example.com",
+    )
+
+    def get_userinfo_mocked(*args):
+        return {
+            "sub": "123",
+            "email": "people@example.com",
+            "first_name": "John",
+            "last_name": "Doe",
+            "registration_number": "12345678901234",
+        }
+
+    monkeypatch.setattr(OIDCAuthenticationBackend, "get_userinfo", get_userinfo_mocked)
+
+    user = klass.get_or_create_user(
+        access_token="test-token", id_token=None, payload=None
+    )
+
+    assert user.organization is not None
+    assert user.organization.registration_id_list == ["12345678901234"]

src/backend/core/tests/organizations/__init__.py

@@ -0,0 +1 @@
+"""Test organization API endpoints."""

src/backend/core/tests/organizations/test_core_api_organizations_retrieve.py

@@ -0,0 +1,91 @@
+"""
+Tests for Organizations API endpoint in People's core app: retrieve
+"""
+
+import pytest
+from rest_framework import status
+
+from core import factories
+
+pytestmark = pytest.mark.django_db
+
+
+def test_api_organizations_retrieve_anonymous(client):
+    """Anonymous users should not be allowed to retrieve an organization."""
+    organization = factories.OrganizationFactory(with_registration_id=True)
+    response = client.get(f"/api/v1.0/organizations/{organization.pk}/")
+
+    assert response.status_code == status.HTTP_401_UNAUTHORIZED
+    assert response.json() == {
+        "detail": "Authentication credentials were not provided."
+    }
+
+
+def test_api_organizations_retrieve_authenticated_unrelated(client):
+    """
+    Authenticated users should not be allowed to retrieve an organization to which they are
+    not related.
+    """
+    user = factories.UserFactory()
+    organization = factories.OrganizationFactory(with_registration_id=True)
+
+    client.force_login(user)
+
+    response = client.get(
+        f"/api/v1.0/organizations/{organization.pk!s}/",
+    )
+    assert response.status_code == status.HTTP_404_NOT_FOUND
+    assert response.json() == {"detail": "No Organization matches the given query."}
+
+
+def test_api_organizations_retrieve_authenticated_belong_to_organization(client):
+    """
+    Authenticated users should be allowed to retrieve an organization to which they
+    belong to.
+    """
+    organization = factories.OrganizationFactory(
+        registration_id_list=["56618615316840", "31561861231231", "98781236231482"],
+        domain_list=["example.com", "example.org"],
+    )
+    user = factories.UserFactory(organization=organization)
+
+    client.force_login(user)
+
+    response = client.get(
+        f"/api/v1.0/organizations/{organization.pk!s}/",
+    )
+
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json() == {
+        "id": str(organization.pk),
+        "name": organization.name,
+        "abilities": {"delete": False, "get": True, "patch": False, "put": False},
+        "domain_list": ["example.com", "example.org"],
+        "registration_id_list": ["56618615316840", "31561861231231", "98781236231482"],
+    }
+
+
+def test_api_organizations_retrieve_authenticated_administrator(client):
+    """
+    Authenticated users should be allowed to retrieve an organization
+    which they administrate.
+    """
+    organization_access = (
+        factories.OrganizationAccessFactory()
+    )  # only role is administrator for now
+    user = organization_access.user
+    organization = organization_access.organization
+
+    client.force_login(user)
+
+    response = client.get(
+        f"/api/v1.0/organizations/{organization.pk!s}/",
+    )
+
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json()["abilities"] == {
+        "delete": False,
+        "get": True,
+        "patch": True,
+        "put": True,
+    }

src/backend/core/tests/organizations/test_core_api_organizations_update.py

@@ -0,0 +1,96 @@
+"""
+Tests for Organizations API endpoint in People's core app: update
+"""
+
+import pytest
+from rest_framework import status
+
+from core import factories
+
+pytestmark = pytest.mark.django_db
+
+
+def test_api_organizations_update_anonymous(client):
+    """Anonymous users should not be allowed to update an organization."""
+    organization = factories.OrganizationFactory(with_registration_id=True)
+    response = client.patch(
+        f"/api/v1.0/organizations/{organization.pk}/",
+        {"name": "New Name"},
+        content_type="application/json",
+    )
+
+    assert response.status_code == status.HTTP_401_UNAUTHORIZED
+    assert response.json() == {
+        "detail": "Authentication credentials were not provided."
+    }
+
+
+def test_api_organizations_update_authenticated_unrelated(client):
+    """
+    Authenticated users should not be allowed to update an organization to which they are
+    not related.
+    """
+    user = factories.UserFactory()
+    organization = factories.OrganizationFactory(with_registration_id=True)
+
+    client.force_login(user)
+
+    response = client.patch(
+        f"/api/v1.0/organizations/{organization.pk}/",
+        {"name": "New Name"},
+        content_type="application/json",
+    )
+    assert response.status_code == status.HTTP_404_NOT_FOUND
+    assert response.json() == {"detail": "No Organization matches the given query."}
+
+
+def test_api_organizations_update_authenticated_belong_to_organization(client):
+    """
+    Authenticated users should NOT be allowed to update an organization to which they
+    belong to.
+    """
+    organization = factories.OrganizationFactory(with_registration_id=True)
+    user = factories.UserFactory(organization=organization)
+
+    client.force_login(user)
+
+    response = client.patch(
+        f"/api/v1.0/organizations/{organization.pk}/",
+        {"name": "New Name"},
+        content_type="application/json",
+    )
+
+    assert response.status_code == status.HTTP_403_FORBIDDEN
+    assert response.json() == {
+        "detail": "You do not have permission to perform this action."
+    }
+
+
+def test_api_organizations_update_authenticated_administrator(client):
+    """
+    Authenticated users should be allowed to update an organization
+    which they administrate.
+    """
+    organization = factories.OrganizationFactory(
+        registration_id_list=["56618615316840", "31561861231231", "98781236231482"],
+        domain_list=["example.com", "example.org"],
+    )
+    organization_access = factories.OrganizationAccessFactory(organization=organization)
+    user = organization_access.user
+
+    client.force_login(user)
+
+    response = client.patch(
+        f"/api/v1.0/organizations/{organization.pk}/",
+        {"name": "New Name"},
+        content_type="application/json",
+    )
+
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json() == {
+        "id": str(organization.pk),
+        "name": "New Name",
+        "abilities": {"delete": False, "get": True, "patch": True, "put": True},
+        "domain_list": ["example.com", "example.org"],
+        "registration_id_list": ["56618615316840", "31561861231231", "98781236231482"],
+    }

src/backend/core/tests/resource_server/__init__.py

@@ -0,0 +1 @@
+"""Core resource server tests."""

src/backend/core/tests/resource_server/test_authentication.py

@@ -0,0 +1,178 @@
+"""Tests for the authentication process of the resource server."""
+
+import base64
+import json
+
+import pytest
+import responses
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import rsa
+from joserfc import jwe as jose_jwe
+from joserfc import jwt as jose_jwt
+from joserfc.rfc7518.rsa_key import RSAKey
+from jwt.utils import to_base64url_uint
+from rest_framework.request import Request as DRFRequest
+from rest_framework.status import HTTP_200_OK, HTTP_401_UNAUTHORIZED
+
+from core.factories import UserFactory
+from core.models import ServiceProvider
+from core.resource_server.authentication import ResourceServerAuthentication
+
+pytestmark = pytest.mark.django_db
+
+
+def build_authorization_bearer(token):
+    """
+    Build an Authorization Bearer header value from a token.
+
+    This can be used like this:
+    client.post(
+        ...
+        HTTP_AUTHORIZATION=f"Bearer {build_authorization_bearer('some_token')}",
+    )
+    """
+    return base64.b64encode(token.encode("utf-8")).decode("utf-8")
+
+
+@responses.activate
+def test_resource_server_authentication_class(client, settings):
+    """
+    Defines the settings for the resource server
+    for a full authentication with introspection process.
+
+    This is an integration test that checks the authentication process
+    when using the ResourceServerAuthentication class.
+
+    This test asserts the DRF request object contains the
+    `resource_server_token_audience` attribute which is used in
+    the resource server views.
+
+    This test uses the `/resource-server/v1.0/teams/` URL as an example
+    because we don't want to create a new URL just for this test.
+    """
+    private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+
+    unencrypted_pem_private_key = private_key.private_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PrivateFormat.TraditionalOpenSSL,
+        encryption_algorithm=serialization.NoEncryption(),
+    )
+
+    pem_public_key = private_key.public_key().public_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PublicFormat.SubjectPublicKeyInfo,
+    )
+
+    settings.OIDC_RS_PRIVATE_KEY_STR = unencrypted_pem_private_key.decode("utf-8")
+    settings.OIDC_RS_ENCRYPTION_KEY_TYPE = "RSA"
+    settings.OIDC_RS_ENCRYPTION_ENCODING = "A256GCM"
+    settings.OIDC_RS_ENCRYPTION_ALGO = "RSA-OAEP"
+    settings.OIDC_RS_SIGNING_ALGO = "RS256"
+    settings.OIDC_RS_CLIENT_ID = "some_client_id"
+    settings.OIDC_RS_CLIENT_SECRET = "some_client_secret"
+
+    settings.OIDC_OP_URL = "https://oidc.example.com"
+    settings.OIDC_VERIFY_SSL = False
+    settings.OIDC_TIMEOUT = 5
+    settings.OIDC_PROXY = None
+    settings.OIDC_OP_JWKS_ENDPOINT = "https://oidc.example.com/jwks"
+    settings.OIDC_OP_INTROSPECTION_ENDPOINT = "https://oidc.example.com/introspect"
+
+    # Mock the JWKS endpoint
+    public_numbers = private_key.public_key().public_numbers()
+    responses.add(
+        responses.GET,
+        settings.OIDC_OP_JWKS_ENDPOINT,
+        body=json.dumps(
+            {
+                "keys": [
+                    {
+                        "kty": settings.OIDC_RS_ENCRYPTION_KEY_TYPE,
+                        "alg": settings.OIDC_RS_SIGNING_ALGO,
+                        "use": "sig",
+                        "kid": "1234567890",
+                        "n": to_base64url_uint(public_numbers.n).decode("ascii"),
+                        "e": to_base64url_uint(public_numbers.e).decode("ascii"),
+                    }
+                ]
+            }
+        ),
+    )
+
+    def encrypt_jwt(json_data):
+        """Encrypt the JWT token for the backend to decrypt."""
+        token = jose_jwt.encode(
+            {
+                "kid": "1234567890",
+                "alg": settings.OIDC_RS_SIGNING_ALGO,
+            },
+            json_data,
+            RSAKey.import_key(unencrypted_pem_private_key),
+            algorithms=[settings.OIDC_RS_SIGNING_ALGO],
+        )
+
+        return jose_jwe.encrypt_compact(
+            protected={
+                "alg": settings.OIDC_RS_ENCRYPTION_ALGO,
+                "enc": settings.OIDC_RS_ENCRYPTION_ENCODING,
+            },
+            plaintext=token,
+            public_key=RSAKey.import_key(pem_public_key),
+            algorithms=[
+                settings.OIDC_RS_ENCRYPTION_ALGO,
+                settings.OIDC_RS_ENCRYPTION_ENCODING,
+            ],
+        )
+
+    responses.add(
+        responses.POST,
+        "https://oidc.example.com/introspect",
+        body=encrypt_jwt(
+            {
+                "iss": "https://oidc.example.com",
+                "aud": "some_client_id",  # settings.OIDC_RS_CLIENT_ID
+                "token_introspection": {
+                    "sub": "very-specific-sub",
+                    "iss": "https://oidc.example.com",
+                    "aud": "some_service_provider",
+                    "scope": "openid groups",
+                    "active": True,
+                },
+            }
+        ),
+    )
+
+    # Try to authenticate while the user does not exist => 401
+    response = client.get(
+        "/resource-server/v1.0/teams/",  # use an exising URL here
+        format="json",
+        HTTP_AUTHORIZATION=f"Bearer {build_authorization_bearer('some_token')}",
+    )
+    assert response.status_code == HTTP_401_UNAUTHORIZED
+    assert ServiceProvider.objects.count() == 0
+
+    # Create a user with the specific sub, the access is authorized
+    UserFactory(sub="very-specific-sub")
+
+    response = client.get(
+        "/resource-server/v1.0/teams/",  # use an exising URL here
+        format="json",
+        HTTP_AUTHORIZATION=f"Bearer {build_authorization_bearer('some_token')}",
+    )
+
+    assert response.status_code == HTTP_200_OK
+
+    response_request = response.renderer_context.get("request")
+    assert isinstance(response_request, DRFRequest)
+    assert isinstance(
+        response_request.successful_authenticator, ResourceServerAuthentication
+    )
+
+    # Check that the user is authenticated
+    assert response_request.user.is_authenticated
+
+    # Check the request contains the resource server token audience
+    assert response_request.resource_server_token_audience == "some_service_provider"
+
+    # Check that no service provider is created here
+    assert ServiceProvider.objects.count() == 0

src/backend/core/tests/resource_server/test_backend.py

@@ -296,7 +296,7 @@ def test_introspect_public_key_import_failure(
 
 def test_verify_user_info_success(resource_server_backend):
     """Test '_verify_user_info' with a successful response."""
-    introspection_response = {"active": True, "scope": "groups"}
+    introspection_response = {"active": True, "scope": "groups", "aud": "123"}
 
     result = resource_server_backend._verify_user_info(introspection_response)
     assert result == introspection_response
@@ -333,7 +333,7 @@ def test_get_user_success(resource_server_backend):
 
     access_token = "valid_access_token"
     mock_jwt = Mock()
-    mock_claims = {"token_introspection": {"sub": "user123"}}
+    mock_claims = {"token_introspection": {"sub": "user123", "aud": "123"}}
     mock_user = Mock()
 
     resource_server_backend._introspect = Mock(return_value=mock_jwt)

src/backend/core/tests/resource_server_api/__init__.py

@@ -0,0 +1 @@
+"""Tests for the resource server API endpoints."""

src/backend/core/tests/resource_server_api/conftest.py

@@ -0,0 +1,79 @@
+"""Defines fixtures for the resource server API tests."""
+
+from contextlib import contextmanager
+from typing import Optional
+from unittest import mock
+
+from django.contrib.auth import get_user_model
+
+import pytest
+import responses
+from faker import Faker
+
+from core.resource_server.authentication import ResourceServerAuthentication
+
+User = get_user_model()
+fake = Faker()
+
+
+@contextmanager
+def _force_login_via_resource_server(
+    client_fixture,
+    user: User,
+    service_provider_audience: Optional[str],
+):
+    """
+    Context manager to authenticate a user with a service provider via
+    a resource server call.
+
+    This allows to authenticate a user with a service provider without doing
+    all the introspection process.
+
+    This is a private function, use the `force_login_via_resource_server`
+    fixture instead.
+
+    The `service_provider_audience` parameter might not match any existing
+    service provider audience, doing so allow to check the behavior when
+    the service provider is not yet known.
+    """
+
+    def mock_authenticate(self, request):  # pylint: disable=unused-argument
+        request.resource_server_token_audience = (
+            service_provider_audience or fake.pystr(min_chars=10, max_chars=10)
+        )
+        return user, "unused-token"
+
+    with mock.patch.object(
+        ResourceServerAuthentication, "authenticate", mock_authenticate
+    ):
+        client_fixture.force_login(
+            user,
+            backend="core.resource_server.authentication.ResourceServerAuthentication",
+        )
+        yield
+
+
+@pytest.fixture(name="force_login_via_resource_server")
+@responses.activate
+def force_login_via_resource_server_fixture():
+    """
+    Fixture to authenticate a user with a service provider via a resource server call.
+
+    Usage:
+    ```
+    def test_login_with_resource_server(
+        client, force_login_via_resource_server,
+    ):
+        user = UserFactory()
+        service_provider = ServiceProviderFactory()
+        with force_login_via_resource_server(client, user, service_provider.audience_id):
+            response = client.get(
+                "/resource-server/v1.0/<whatever>/",
+                format="json",
+                HTTP_AUTHORIZATION="Bearer b64untestedbearertoken",
+            )
+
+            # response is authenticated
+    ```
+    """
+    return _force_login_via_resource_server

src/backend/core/tests/resource_server_api/teams/__init__.py

@@ -0,0 +1 @@
+"""Tests for the resource server Team API endpoints."""

src/backend/core/tests/resource_server_api/teams/test_create.py

@@ -0,0 +1,163 @@
+"""
+Tests for Teams API endpoint in People's core app: create
+"""
+
+import pytest
+from rest_framework.status import (
+    HTTP_201_CREATED,
+    HTTP_401_UNAUTHORIZED,
+)
+from rest_framework.test import APIClient
+
+from core.factories import OrganizationFactory, ServiceProviderFactory, UserFactory
+from core.models import ServiceProvider, Team
+
+pytestmark = pytest.mark.django_db
+
+
+def test_api_teams_create_anonymous():
+    """Anonymous users should not be allowed to create teams."""
+    response = APIClient().post(
+        "/resource-server/v1.0/teams/",
+        {
+            "name": "my team",
+        },
+    )
+
+    assert response.status_code == HTTP_401_UNAUTHORIZED
+    assert not Team.objects.exists()
+
+
+def test_api_teams_create_authenticated_new_service_provider(
+    client, force_login_via_resource_server
+):
+    """
+    Authenticated users should be able to create teams and should automatically be declared
+    as the owner of the newly created team and a new service provider should be created and
+    associated to the team.
+    """
+    organization = OrganizationFactory(with_registration_id=True)
+    user = UserFactory(organization=organization)
+    assert ServiceProvider.objects.count() == 0
+
+    with force_login_via_resource_server(client, user, "some_service_provider"):
+        response = client.post(
+            "/resource-server/v1.0/teams/",
+            {
+                "name": "my team",
+            },
+            format="json",
+            HTTP_AUTHORIZATION="Bearer b64untestedbearertoken",
+        )
+
+    assert response.status_code == HTTP_201_CREATED
+
+    team = Team.objects.get()
+    team_access = team.accesses.get()
+    service_provider = ServiceProvider.objects.get()  # service provider created
+
+    assert response.json() == {
+        "created_at": team.created_at.strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
+        "id": str(team.pk),
+        "name": "my team",
+        "updated_at": team.updated_at.strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
+    }
+
+    # check team data
+    assert team.name == "my team"
+    assert team.organization == organization
+
+    # check team access data
+    assert team_access.role == "owner"
+    assert team_access.user == user
+
+    # check service provider data
+    assert service_provider.audience_id == "some_service_provider"
+
+
+def test_api_teams_create_authenticated_existing_service_provider(
+    client,
+    force_login_via_resource_server,
+):
+    """
+    Authenticated users should be able to create teams and should automatically be declared
+    as the owner of the newly created team and an existing service provider should be associated
+    to the team.
+    """
+    user = UserFactory()
+    service_provider = ServiceProviderFactory()
+    with force_login_via_resource_server(client, user, service_provider.audience_id):
+        response = client.post(
+            "/resource-server/v1.0/teams/",
+            {
+                "name": "my team",
+            },
+            format="json",
+            HTTP_AUTHORIZATION="Bearer b64untestedbearertoken",
+        )
+
+    assert response.status_code == HTTP_201_CREATED
+
+    assert ServiceProvider.objects.count() == 1  # no object created
+    team = Team.objects.get()  # team created
+    assert team.service_providers.get().audience_id == service_provider.audience_id
+    assert team.name == "my team"
+    assert team.accesses.filter(role="owner", user=user).exists()
+
+
+def test_api_teams_create_cannot_override_organization(
+    client, force_login_via_resource_server
+):
+    """
+    Authenticated users should be able to create teams and not
+    be able to set the organization manually (for now).
+    """
+    organization = OrganizationFactory(with_registration_id=True)
+    user = UserFactory(organization=organization)
+    service_provider = ServiceProviderFactory()
+
+    with force_login_via_resource_server(client, user, service_provider.audience_id):
+        response = client.post(
+            "/resource-server/v1.0/teams/",
+            {
+                "name": "my team",
+                "organization": OrganizationFactory(
+                    with_registration_id=True
+                ).pk,  # ignored
+            },
+            format="json",
+        )
+
+    assert response.status_code == HTTP_201_CREATED
+    team = Team.objects.get()
+    assert team.name == "my team"
+    assert team.organization == organization
+    assert team.accesses.filter(role="owner", user=user).exists()
+
+
+def test_api_teams_create_cannot_override_service_provider(
+    client, force_login_via_resource_server
+):
+    """
+    Authenticated users should be able to create teams and not
+    be able to set the team service provider manually.
+    """
+    user = UserFactory(with_organization=True)
+    service_provider = ServiceProviderFactory()
+
+    other_service_provider = ServiceProviderFactory()
+    with force_login_via_resource_server(client, user, service_provider.audience_id):
+        response = client.post(
+            "/resource-server/v1.0/teams/",
+            {
+                "name": "my team",
+                "service_providers": [str(other_service_provider.pk)],  # ignored
+            },
+            format="json",
+        )
+
+    assert response.status_code == HTTP_201_CREATED
+
+    team = Team.objects.get()
+    assert team.name == "my team"
+    assert team.service_providers.get().audience_id == service_provider.audience_id

src/backend/core/tests/resource_server_api/teams/test_delete.py

@@ -0,0 +1,49 @@
+"""
+Tests for Teams API endpoint in People's core app: delete
+"""
+
+import pytest
+from rest_framework.status import (
+    HTTP_401_UNAUTHORIZED,
+    HTTP_405_METHOD_NOT_ALLOWED,
+)
+from rest_framework.test import APIClient
+
+from core import factories, models
+
+pytestmark = pytest.mark.django_db
+
+
+def test_api_teams_delete_anonymous():
+    """Anonymous users should not be allowed to destroy a team."""
+    team = factories.TeamFactory()
+
+    response = APIClient().delete(
+        f"/resource-server/v1.0/teams/{team.id!s}/",
+    )
+
+    assert response.status_code == HTTP_401_UNAUTHORIZED
+    assert models.Team.objects.count() == 1
+
+
+def test_api_teams_delete_not_allowed(client, force_login_via_resource_server):
+    """
+    Authenticated users should not be allowed to delete a team from a resource
+    server, even if they have the right permissions.
+
+    This may be implemented in the future, but for now, it is not allowed.
+    """
+    user = factories.UserFactory()
+    service_provider = factories.ServiceProviderFactory()
+    team = factories.TeamFactory(
+        users=[(user, "owner")], service_providers=[service_provider]
+    )
+
+    with force_login_via_resource_server(client, user, service_provider.audience_id):
+        response = client.delete(
+            f"/resource-server/v1.0/teams/{team.id!s}/",
+        )
+
+    assert response.status_code == HTTP_405_METHOD_NOT_ALLOWED
+    assert response.json() == {"detail": 'Method "DELETE" not allowed.'}
+    assert models.Team.objects.count() == 1

src/backend/core/tests/resource_server_api/teams/test_list.py

@@ -0,0 +1,184 @@
+"""
+Tests for Teams API endpoint in People's core app: list
+"""
+
+import pytest
+from rest_framework.status import HTTP_200_OK, HTTP_401_UNAUTHORIZED
+from rest_framework.test import APIClient
+
+from core import factories
+
+pytestmark = pytest.mark.django_db
+
+
+def test_api_teams_list_anonymous():
+    """Anonymous users should not be allowed to list teams."""
+    factories.TeamFactory.create_batch(2)
+
+    response = APIClient().get("/resource-server/v1.0/teams/")
+
+    assert response.status_code == HTTP_401_UNAUTHORIZED
+    assert response.json() == {
+        "detail": "Authentication credentials were not provided."
+    }
+
+
+def test_api_teams_list_authenticated(  # pylint: disable=too-many-locals
+    client, django_assert_num_queries, force_login_via_resource_server
+):
+    """
+    Authenticated users should be able to list teams
+    they are an owner/administrator/member of, and only list from the
+    requesting service provider should appear.
+    """
+    user = factories.UserFactory()
+    service_provider = factories.ServiceProviderFactory()
+    hidden_service_provider = factories.ServiceProviderFactory()
+
+    team_access_1 = factories.TeamAccessFactory(
+        user=user, team__service_providers=[service_provider], role="member"
+    )
+    team_1 = team_access_1.team
+
+    team_access_2 = factories.TeamAccessFactory(
+        user=user,
+        team__service_providers=[hidden_service_provider, service_provider],
+        role="member",
+    )
+    team_2 = team_access_2.team
+
+    team_access_3 = factories.TeamAccessFactory(
+        user=user, team__service_providers=[service_provider], role="administrator"
+    )
+    team_3 = team_access_3.team
+
+    team_access_4 = factories.TeamAccessFactory(
+        user=user, team__service_providers=[service_provider], role="owner"
+    )
+    team_4 = team_access_4.team
+
+    # Team filtered out because of the service provider
+    _not_included_team_access = factories.TeamAccessFactory(
+        user=user, team__service_providers=[hidden_service_provider]
+    )
+
+    # Authenticate using the resource server, ie via the Authorization header
+    with force_login_via_resource_server(client, user, service_provider.audience_id):
+        with django_assert_num_queries(4):  # Count, Team, ServiceProvider, TeamAccess
+            response = client.get(
+                "/resource-server/v1.0/teams/?ordering=created_at",
+                format="json",
+                HTTP_AUTHORIZATION="Bearer b64untestedbearertoken",
+            )
+
+    assert response.status_code == HTTP_200_OK
+    assert response.json() == {
+        "count": 4,
+        "next": None,
+        "previous": None,
+        "results": [
+            {
+                "created_at": team_1.created_at.strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
+                "id": str(team_1.pk),
+                "name": team_1.name,
+                "updated_at": team_1.updated_at.strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
+            },
+            {
+                "created_at": team_2.created_at.strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
+                "id": str(team_2.pk),
+                "name": team_2.name,
+                "updated_at": team_2.updated_at.strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
+            },
+            {
+                "created_at": team_3.created_at.strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
+                "id": str(team_3.pk),
+                "name": team_3.name,
+                "updated_at": team_3.updated_at.strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
+            },
+            {
+                "created_at": team_4.created_at.strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
+                "id": str(team_4.pk),
+                "name": team_4.name,
+                "updated_at": team_4.updated_at.strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
+            },
+        ],
+    }
+
+
+def test_api_teams_list_authenticated_new_service_provider(
+    client, force_login_via_resource_server
+):
+    """
+    Team list from not yet known service provider should be empty (not fail).
+
+    Teams without service providers should not be listed.
+    """
+    user = factories.UserFactory()
+    _team = factories.TeamFactory(users=[user])
+
+    with force_login_via_resource_server(client, user, "some_service_provider"):
+        response = client.get(
+            "/resource-server/v1.0/teams/",
+        )
+
+    assert response.status_code == HTTP_200_OK
+    assert response.json() == {
+        "count": 0,
+        "next": None,
+        "previous": None,
+        "results": [],
+    }
+
+
+def test_api_teams_list_authenticated_distinct(client, force_login_via_resource_server):
+    """A team with several related users should only be listed once."""
+    user = factories.UserFactory()
+    service_provider = factories.ServiceProviderFactory()
+
+    other_user = factories.UserFactory()
+
+    team = factories.TeamFactory(
+        users=[user, other_user], service_providers=[service_provider]
+    )
+
+    with force_login_via_resource_server(client, user, service_provider.audience_id):
+        response = client.get(
+            "/resource-server/v1.0/teams/",
+        )
+
+    assert response.status_code == HTTP_200_OK
+    content = response.json()
+    assert content["count"] == 1
+
+    results = content["results"]
+    assert len(results) == 1
+    assert results[0]["id"] == str(team.id)
+
+
+def test_api_teams_order_param(client, force_login_via_resource_server):
+    """
+    Test that the 'created_at' field is sorted in ascending order
+    when the 'ordering' query parameter is set.
+    """
+    user = factories.UserFactory()
+    service_provider = factories.ServiceProviderFactory()
+
+    team_ids = [
+        str(team.id)
+        for team in factories.TeamFactory.create_batch(
+            5, users=[user], service_providers=[service_provider]
+        )
+    ]
+
+    with force_login_via_resource_server(client, user, service_provider.audience_id):
+        response = client.get(
+            "/resource-server/v1.0/teams/?ordering=created_at",
+        )
+    assert response.status_code == 200
+
+    response_data = response.json()
+    response_team_ids = [team["id"] for team in response_data["results"]]
+
+    assert (
+        response_team_ids == team_ids
+    ), "created_at values are not sorted from oldest to newest"

src/backend/core/tests/resource_server_api/teams/test_retrieve.py

@@ -0,0 +1,99 @@
+"""
+Tests for Teams API endpoint in People's core app: retrieve
+"""
+
+import pytest
+from rest_framework import status
+from rest_framework.status import HTTP_404_NOT_FOUND
+from rest_framework.test import APIClient
+
+from core import factories
+from core.factories import UserFactory
+
+pytestmark = pytest.mark.django_db
+
+
+def test_api_teams_retrieve_anonymous():
+    """Anonymous users should not be allowed to retrieve a team."""
+    team = factories.TeamFactory()
+    response = APIClient().get(f"/resource-server/v1.0/teams/{team.id}/")
+
+    assert response.status_code == status.HTTP_401_UNAUTHORIZED
+    assert response.json() == {
+        "detail": "Authentication credentials were not provided."
+    }
+
+
+def test_api_teams_retrieve_authenticated_unrelated(
+    client, force_login_via_resource_server
+):
+    """
+    Authenticated users should not be allowed to retrieve a team to which they are
+    not related.
+    """
+    user = factories.UserFactory()
+    service_provider = factories.ServiceProviderFactory()
+
+    team = factories.TeamFactory(service_providers=[service_provider])
+
+    with force_login_via_resource_server(client, user, service_provider.audience_id):
+        response = client.get(
+            f"/resource-server/v1.0/teams/{team.id!s}/",
+        )
+    assert response.status_code == status.HTTP_404_NOT_FOUND
+    assert response.json() == {"detail": "No Team matches the given query."}
+
+
+def test_api_teams_retrieve_authenticated_related(
+    client, force_login_via_resource_server
+):
+    """
+    Authenticated users should be allowed to retrieve a team to which they
+    are related whatever the role even if the request is authenticated via
+    a resource server.
+    """
+    service_provider = factories.ServiceProviderFactory(
+        audience_id="some_service_provider"
+    )
+    user = factories.UserFactory()
+    team = factories.TeamFactory(users=[user], service_providers=[service_provider])
+
+    with force_login_via_resource_server(client, user, service_provider.audience_id):
+        response = client.get(
+            f"/resource-server/v1.0/teams/{team.id!s}/",
+            HTTP_AUTHORIZATION="Bearer b64untestedbearertoken",
+        )
+
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json() == {
+        "id": str(team.id),
+        "name": team.name,
+        "created_at": team.created_at.isoformat().replace("+00:00", "Z"),
+        "updated_at": team.updated_at.isoformat().replace("+00:00", "Z"),
+    }
+
+
+def test_api_teams_retrieve_authenticated_other_service_provider(
+    client, force_login_via_resource_server
+):
+    """
+    Authenticated users should not be able to retrieve a team
+    if the request is authenticated via a different resource server.
+    """
+    user = UserFactory()
+    service_provider = factories.ServiceProviderFactory()
+
+    other_service_provider = factories.ServiceProviderFactory(
+        audience_id="some_service_provider"
+    )
+    team = factories.TeamFactory(
+        users=[user], service_providers=[other_service_provider]
+    )
+
+    with force_login_via_resource_server(client, user, service_provider.audience_id):
+        response = client.get(
+            f"/resource-server/v1.0/teams/{team.id!s}/",
+            HTTP_AUTHORIZATION="Bearer b64untestedbearertoken",
+        )
+
+    assert response.status_code == HTTP_404_NOT_FOUND

src/backend/core/tests/resource_server_api/teams/test_update.py

@@ -0,0 +1,246 @@
+"""
+Tests for Teams API endpoint in People's core app: update
+"""
+
+import pytest
+from rest_framework.status import (
+    HTTP_200_OK,
+    HTTP_401_UNAUTHORIZED,
+    HTTP_403_FORBIDDEN,
+    HTTP_404_NOT_FOUND,
+)
+from rest_framework.test import APIClient
+
+from core import factories
+from core.api.resource_server import serializers
+
+pytestmark = pytest.mark.django_db
+
+
+def test_api_teams_update_anonymous():
+    """Anonymous users should not be allowed to update a team."""
+    team = factories.TeamFactory()
+    old_team_values = serializers.TeamSerializer(instance=team).data
+
+    new_team_values = serializers.TeamSerializer(instance=factories.TeamFactory()).data
+    response = APIClient().put(
+        f"/resource-server/v1.0/teams/{team.id!s}/",
+        new_team_values,
+        content_type="application/json",
+    )
+    assert response.status_code == HTTP_401_UNAUTHORIZED
+    assert response.json() == {
+        "detail": "Authentication credentials were not provided."
+    }
+
+    team.refresh_from_db()
+    team_values = serializers.TeamSerializer(instance=team).data
+    assert team_values == old_team_values
+
+
+def test_api_teams_update_authenticated_unrelated(
+    client, force_login_via_resource_server
+):
+    """
+    Authenticated users should not be allowed to update a team to which they are not related.
+    """
+    user = factories.UserFactory()
+    service_provider = factories.ServiceProviderFactory()
+    team = factories.TeamFactory(service_providers=[service_provider])
+
+    old_team_values = serializers.TeamSerializer(instance=team).data
+
+    new_team_values = serializers.TeamSerializer(instance=factories.TeamFactory()).data
+
+    with force_login_via_resource_server(client, user, service_provider.audience_id):
+        response = client.put(
+            f"/resource-server/v1.0/teams/{team.id!s}/",
+            new_team_values,
+            content_type="application/json",
+            HTTP_AUTHORIZATION="Bearer b64untestedbearertoken",
+        )
+
+    assert response.status_code == HTTP_404_NOT_FOUND
+    assert response.json() == {"detail": "No Team matches the given query."}
+
+    team.refresh_from_db()
+    team_values = serializers.TeamSerializer(instance=team).data
+    assert team_values == old_team_values
+
+
+def test_api_teams_update_authenticated(
+    client,
+    force_login_via_resource_server,
+):
+    """
+    Authenticated users should be allowed to update a team to which they
+    are related whatever the role even if the request is authenticated via
+    a resource server.
+    """
+    service_provider = factories.ServiceProviderFactory(
+        audience_id="some_service_provider"
+    )
+    user = factories.UserFactory()
+    team = factories.TeamFactory(
+        name="Old name",
+        users=[(user, "owner")],
+        service_providers=[service_provider],
+    )
+
+    with force_login_via_resource_server(client, user, service_provider.audience_id):
+        response = client.put(
+            f"/resource-server/v1.0/teams/{team.id!s}/",
+            data=serializers.TeamSerializer(instance=team).data
+            | {
+                "name": "New name",
+            },
+            content_type="application/json",
+            HTTP_AUTHORIZATION="Bearer b64untestedbearertoken",
+        )
+
+    assert response.status_code == HTTP_200_OK
+
+    team.refresh_from_db()
+    assert team.name == "New name"
+
+
+def test_api_teams_update_authenticated_other_resource_server(
+    client, force_login_via_resource_server
+):
+    """
+    Authenticated users should not be able to update a team for which they are directly
+    owner, if the request is authenticated via a different service provider.
+    """
+    user = factories.UserFactory()
+    service_provider = factories.ServiceProviderFactory()
+
+    other_service_provider = factories.ServiceProviderFactory(
+        audience_id="some_service_provider"
+    )
+    team = factories.TeamFactory(
+        name="Old name",
+        users=[(user, "owner")],
+        service_providers=[other_service_provider],
+    )
+
+    with force_login_via_resource_server(client, user, service_provider.audience_id):
+        response = client.put(
+            f"/resource-server/v1.0/teams/{team.id!s}/",
+            data=serializers.TeamSerializer(instance=team).data
+            | {
+                "name": "New name",
+            },
+            content_type="application/json",
+            HTTP_AUTHORIZATION="Bearer b64untestedbearertoken",
+        )
+
+    assert response.status_code == HTTP_404_NOT_FOUND
+    assert response.json() == {"detail": "No Team matches the given query."}
+
+    team.refresh_from_db()
+    assert team.name == "Old name"
+
+
+def test_api_teams_update_authenticated_members(
+    client, force_login_via_resource_server
+):
+    """
+    Users who are members of a team but not administrators should
+    not be allowed to update it.
+    """
+    user = factories.UserFactory()
+    service_provider = factories.ServiceProviderFactory()
+
+    team = factories.TeamFactory(
+        users=[(user, "member")], service_providers=[service_provider]
+    )
+    old_team_values = serializers.TeamSerializer(instance=team).data
+
+    new_team_values = serializers.TeamSerializer(instance=factories.TeamFactory()).data
+
+    with force_login_via_resource_server(client, user, service_provider.audience_id):
+        response = client.put(
+            f"/resource-server/v1.0/teams/{team.id!s}/",
+            new_team_values,
+            content_type="application/json",
+            HTTP_AUTHORIZATION="Bearer b64untestedbearertoken",
+        )
+
+    assert response.status_code == HTTP_403_FORBIDDEN
+    assert response.json() == {
+        "detail": "You do not have permission to perform this action."
+    }
+
+    team.refresh_from_db()
+    team_values = serializers.TeamSerializer(instance=team).data
+    assert team_values == old_team_values
+
+
+@pytest.mark.parametrize("role", ["owner", "administrator"])
+def test_api_teams_update_authenticated_administrators(
+    client, force_login_via_resource_server, role
+):
+    """Administrators or owners of a team should be allowed to update it."""
+    user = factories.UserFactory()
+    service_provider = factories.ServiceProviderFactory()
+
+    team = factories.TeamFactory(
+        users=[(user, role)],
+        service_providers=[service_provider],
+        name="old name",
+    )
+    initial_created_at = team.created_at
+    initial_updated_at = team.updated_at
+    initial_pk = team.pk
+
+    # generate new random values
+    new_values = serializers.TeamSerializer(instance=factories.TeamFactory.build()).data
+
+    with force_login_via_resource_server(client, user, service_provider.audience_id):
+        response = client.put(
+            f"/resource-server/v1.0/teams/{team.id!s}/",
+            new_values,
+            content_type="application/json",
+            HTTP_AUTHORIZATION="Bearer b64untestedbearertoken",
+        )
+    assert response.status_code == HTTP_200_OK
+
+    team.refresh_from_db()
+    assert team.pk == initial_pk
+    assert team.name == new_values["name"]
+    assert team.created_at == initial_created_at
+    assert team.updated_at > initial_updated_at
+
+
+@pytest.mark.parametrize("role", ["owner", "administrator"])
+def test_api_teams_update_administrator_or_owner_of_another(
+    client, force_login_via_resource_server, role
+):
+    """
+    Being administrator or owner of a team should not grant authorization to update
+    another team.
+    """
+    user = factories.UserFactory()
+    service_provider = factories.ServiceProviderFactory()
+
+    factories.TeamFactory(users=[(user, role)], service_providers=[service_provider])
+
+    team = factories.TeamFactory(name="Old name", service_providers=[service_provider])
+    old_team_values = serializers.TeamSerializer(instance=team).data
+
+    new_team_values = serializers.TeamSerializer(instance=factories.TeamFactory()).data
+
+    with force_login_via_resource_server(client, user, service_provider.audience_id):
+        response = client.put(
+            f"/resource-server/v1.0/teams/{team.id!s}/",
+            new_team_values,
+            content_type="application/json",
+            HTTP_AUTHORIZATION="Bearer b64untestedbearertoken",
+        )
+
+    assert response.status_code == HTTP_404_NOT_FOUND
+    assert response.json() == {"detail": "No Team matches the given query."}
+
+    team.refresh_from_db()
+    team_values = serializers.TeamSerializer(instance=team).data
+    assert team_values == old_team_values

src/backend/core/tests/service_providers/__init__.py

@@ -0,0 +1,3 @@
+"""
+Test for the service providers viewset.
+"""

src/backend/core/tests/service_providers/test_core_api_service_providers_list.py

@@ -0,0 +1,91 @@
+"""
+Tests for Service Provider API endpoint in People's core app: list
+"""
+
+import pytest
+from rest_framework.status import HTTP_200_OK, HTTP_401_UNAUTHORIZED
+
+from core import factories
+
+pytestmark = pytest.mark.django_db
+
+
+def test_api_service_providers_list_anonymous(client):
+    """Anonymous users should not be allowed to list service providers."""
+    factories.ServiceProviderFactory.create_batch(2)
+
+    response = client.get("/api/v1.0/service-providers/")
+
+    assert response.status_code == HTTP_401_UNAUTHORIZED
+    assert response.json() == {
+        "detail": "Authentication credentials were not provided."
+    }
+
+
+def test_api_service_providers_list_authenticated(client):
+    """
+    Authenticated users should be able to list service providers
+    of their organization.
+    """
+    user = factories.UserFactory(with_organization=True)
+    client.force_login(user)
+
+    service_provider_1 = factories.ServiceProviderFactory(
+        name="A", organizations=[user.organization]
+    )
+    service_provider_2 = factories.ServiceProviderFactory(
+        name="B", organizations=[user.organization]
+    )
+
+    # Generate some not fetched data
+    factories.ServiceProviderFactory.create_batch(
+        2, organizations=[factories.OrganizationFactory(with_registration_id=True)]
+    )  # Other service providers
+    factories.TeamFactory(
+        users=[user], service_providers=[factories.ServiceProviderFactory()]
+    )
+
+    response = client.get(
+        "/api/v1.0/service-providers/",
+    )
+
+    assert response.status_code == HTTP_200_OK
+    assert response.json() == {
+        "count": 2,
+        "next": None,
+        "previous": None,
+        "results": [
+            {
+                "audience_id": str(service_provider_1.audience_id),
+                "id": str(service_provider_1.pk),
+                "name": "A",
+            },
+            {
+                "audience_id": str(service_provider_2.audience_id),
+                "id": str(service_provider_2.pk),
+                "name": "B",
+            },
+        ],
+    }
+
+
+def test_api_service_providers_order(client):
+    """Test that the service providers are sorted as requested."""
+    user = factories.UserFactory(with_organization=True)
+    factories.ServiceProviderFactory(name="A", organizations=[user.organization])
+    factories.ServiceProviderFactory(name="B", organizations=[user.organization])
+
+    client.force_login(user)
+
+    # Test ordering by name descending
+    response = client.get("/api/v1.0/service-providers/?ordering=-name")
+    assert response.status_code == 200
+    response_data = response.json()["results"]
+    assert response_data[0]["name"] == "B"
+    assert response_data[1]["name"] == "A"
+
+    # Test ordering by creation date ascending
+    response = client.get("/api/v1.0/service-providers/?ordering=created_at")
+    response_data = response.json()["results"]
+    assert response_data[0]["name"] == "A"
+    assert response_data[1]["name"] == "B"

src/backend/core/tests/service_providers/test_core_api_service_providers_retrieve.py

@@ -0,0 +1,85 @@
+"""
+Tests for Service Provider API endpoint in People's core app: retrieve
+"""
+
+import pytest
+from rest_framework.status import HTTP_200_OK, HTTP_401_UNAUTHORIZED, HTTP_404_NOT_FOUND
+
+from core import factories
+
+pytestmark = pytest.mark.django_db
+
+
+def test_api_service_providers_retrieve_anonymous(client):
+    """Anonymous users should not be allowed to retrieve service providers."""
+    service_provider = factories.ServiceProviderFactory()
+
+    response = client.get(f"/api/v1.0/service-providers/{service_provider.pk}/")
+
+    assert response.status_code == HTTP_401_UNAUTHORIZED
+    assert response.json() == {
+        "detail": "Authentication credentials were not provided."
+    }
+
+
+def test_api_service_providers_retrieve_authenticated_allowed(client):
+    """
+    Authenticated users should be able to retrieve service providers
+    of their organization.
+    """
+    user = factories.UserFactory(with_organization=True)
+    client.force_login(user)
+
+    service_provider = factories.ServiceProviderFactory(
+        organizations=[user.organization]
+    )
+
+    response = client.get(f"/api/v1.0/service-providers/{service_provider.pk}/")
+
+    assert response.status_code == HTTP_200_OK
+    assert response.json() == {
+        "audience_id": str(service_provider.audience_id),
+        "id": str(service_provider.pk),
+        "name": service_provider.name,
+    }
+
+
+def test_api_service_providers_retrieve_authenticated_other_organization(client):
+    """
+    Authenticated users should not be able to retrieve service providers
+    of other organization.
+    """
+    user = factories.UserFactory(with_organization=True)
+    client.force_login(user)
+
+    service_provider = factories.ServiceProviderFactory(
+        organizations=[factories.OrganizationFactory(with_registration_id=True)]
+    )
+
+    response = client.get(f"/api/v1.0/service-providers/{service_provider.pk}/")
+
+    assert response.status_code == HTTP_404_NOT_FOUND
+    assert response.json() == {"detail": "No ServiceProvider matches the given query."}
+
+
+def test_api_service_providers_retrieve_authenticated_on_teams(client):
+    """
+    Authenticated users should not be able to retrieve service providers
+    just because it is related to one of their teams if it is not related
+    to their organization (might change later if needed).
+    """
+    user = factories.UserFactory(with_organization=True)
+    client.force_login(user)
+
+    other_organization = factories.OrganizationFactory(with_registration_id=True)
+    service_provider = factories.ServiceProviderFactory()
+    factories.TeamFactory(
+        users=[user],
+        organization=other_organization,
+        service_providers=[service_provider],
+    )
+
+    response = client.get(f"/api/v1.0/service-providers/{service_provider.pk}/")
+
+    assert response.status_code == HTTP_404_NOT_FOUND
+    assert response.json() == {"detail": "No ServiceProvider matches the given query."}

src/backend/core/tests/swagger/__init__.py

@@ -0,0 +1 @@
+"""Core Swagger tests."""

src/backend/core/tests/team_accesses/__init__.py

@@ -0,0 +1 @@
+"""Team accesses tests package."""

src/backend/core/tests/team_accesses/test_api_team_accesses_update.py

@@ -9,7 +9,7 @@ import pytest
 from rest_framework.test import APIClient
 
 from core import factories, models
-from core.api import serializers
+from core.api.client import serializers
 
 pytestmark = pytest.mark.django_db
 

src/backend/core/tests/teams/__init__.py

@@ -0,0 +1 @@
+"""Teams tests package."""

src/backend/core/tests/teams/test_core_api_teams_create.py

@@ -5,12 +5,11 @@ Tests for Teams API endpoint in People's core app: create
 import pytest
 from rest_framework.status import (
     HTTP_201_CREATED,
-    HTTP_400_BAD_REQUEST,
     HTTP_401_UNAUTHORIZED,
 )
 from rest_framework.test import APIClient
 
-from core.factories import TeamFactory, UserFactory
+from core.factories import OrganizationFactory, UserFactory
 from core.models import Team
 
 pytestmark = pytest.mark.django_db
@@ -34,7 +33,8 @@ def test_api_teams_create_authenticated():
     Authenticated users should be able to create teams and should automatically be declared
     as the owner of the newly created team.
     """
-    user = UserFactory()
+    organization = OrganizationFactory(with_registration_id=True)
+    user = UserFactory(organization=organization)
 
     client = APIClient()
     client.force_login(user)
@@ -50,76 +50,34 @@ def test_api_teams_create_authenticated():
     assert response.status_code == HTTP_201_CREATED
     team = Team.objects.get()
     assert team.name == "my team"
+    assert team.organization == organization
     assert team.accesses.filter(role="owner", user=user).exists()
 
 
-def test_api_teams_create_authenticated_slugify_name():
+def test_api_teams_create_cannot_override_organization():
     """
-    Creating teams should automatically generate a slug.
+    Authenticated users should be able to create teams and not
+    be able to set the organization manually (for now).
     """
-    user = UserFactory()
+    organization = OrganizationFactory(with_registration_id=True)
+    user = UserFactory(organization=organization)
+
     client = APIClient()
     client.force_login(user)
 
     response = client.post(
         "/api/v1.0/teams/",
-        {"name": "my team"},
+        {
+            "name": "my team",
+            "organization": OrganizationFactory(
+                with_registration_id=True
+            ).pk,  # ignored
+        },
+        format="json",
     )
 
     assert response.status_code == HTTP_201_CREATED
     team = Team.objects.get()
     assert team.name == "my team"
-    assert team.slug == "my-team"
-
-
-@pytest.mark.parametrize(
-    "param",
-    [
-        ("my team", "my-team"),
-        ("my     team", "my-team"),
-        ("MY TEAM TOO", "my-team-too"),
-        ("mon équipe", "mon-equipe"),
-        ("front devs & UX", "front-devs-ux"),
-    ],
-)
-def test_api_teams_create_authenticated_expected_slug(param):
-    """
-    Creating teams should automatically create unaccented, no unicode, lower-case slug.
-    """
-    user = UserFactory()
-
-    client = APIClient()
-    client.force_login(user)
-
-    response = client.post(
-        "/api/v1.0/teams/",
-        {
-            "name": param[0],
-        },
-    )
-
-    assert response.status_code == HTTP_201_CREATED
-    team = Team.objects.get()
-    assert team.name == param[0]
-    assert team.slug == param[1]
-
-
-def test_api_teams_create_authenticated_unique_slugs():
-    """
-    Creating teams should raise an error if already existing slug.
-    """
-    TeamFactory(name="existing team")
-    user = UserFactory()
-
-    client = APIClient()
-    client.force_login(user)
-
-    response = client.post(
-        "/api/v1.0/teams/",
-        {
-            "name": "èxisting team",
-        },
-    )
-
-    assert response.status_code == HTTP_400_BAD_REQUEST
-    assert response.json()["slug"] == ["Team with this Slug already exists."]
+    assert team.organization == organization
+    assert team.accesses.filter(role="owner", user=user).exists()

src/backend/core/tests/teams/test_core_api_teams_list.py

@@ -2,10 +2,7 @@
 Tests for Teams API endpoint in People's core app: list
 """
 
-from unittest import mock
-
 import pytest
-from rest_framework.pagination import PageNumberPagination
 from rest_framework.status import HTTP_200_OK, HTTP_401_UNAUTHORIZED
 from rest_framework.test import APIClient
 
@@ -47,60 +44,13 @@ def test_api_teams_list_authenticated():
     )
 
     assert response.status_code == HTTP_200_OK
-    results = response.json()["results"]
+    results = response.json()
+
     assert len(results) == 5
     results_id = {result["id"] for result in results}
     assert expected_ids == results_id
 
 
-@mock.patch.object(PageNumberPagination, "get_page_size", return_value=2)
-def test_api_teams_list_pagination(
-    _mock_page_size,
-):
-    """Pagination should work as expected."""
-    user = factories.UserFactory()
-
-    client = APIClient()
-    client.force_login(user)
-
-    team_ids = [
-        str(access.team.id)
-        for access in factories.TeamAccessFactory.create_batch(3, user=user)
-    ]
-
-    # Get page 1
-    response = client.get(
-        "/api/v1.0/teams/",
-    )
-
-    assert response.status_code == HTTP_200_OK
-    content = response.json()
-
-    assert content["count"] == 3
-    assert content["next"] == "http://testserver/api/v1.0/teams/?page=2"
-    assert content["previous"] is None
-
-    assert len(content["results"]) == 2
-    for item in content["results"]:
-        team_ids.remove(item["id"])
-
-    # Get page 2
-    response = client.get(
-        "/api/v1.0/teams/?page=2",
-    )
-
-    assert response.status_code == HTTP_200_OK
-    content = response.json()
-
-    assert content["count"] == 3
-    assert content["next"] is None
-    assert content["previous"] == "http://testserver/api/v1.0/teams/"
-
-    assert len(content["results"]) == 1
-    team_ids.remove(content["results"][0]["id"])
-    assert team_ids == []
-
-
 def test_api_teams_list_authenticated_distinct():
     """A team with several related users should only be listed once."""
     user = factories.UserFactory()
@@ -118,8 +68,8 @@ def test_api_teams_list_authenticated_distinct():
 
     assert response.status_code == HTTP_200_OK
     content = response.json()
-    assert len(content["results"]) == 1
-    assert content["results"][0]["id"] == str(team.id)
+    assert len(content) == 1
+    assert content[0]["id"] == str(team.id)
 
 
 def test_api_teams_order():
@@ -142,7 +92,7 @@ def test_api_teams_order():
     assert response.status_code == 200
 
     response_data = response.json()
-    response_team_ids = [team["id"] for team in response_data["results"]]
+    response_team_ids = [team["id"] for team in response_data]
 
     team_ids.reverse()
     assert (
@@ -170,8 +120,7 @@ def test_api_teams_order_param():
     assert response.status_code == 200
 
     response_data = response.json()
-
-    response_team_ids = [team["id"] for team in response_data["results"]]
+    response_team_ids = [team["id"] for team in response_data]
 
     assert (
         response_team_ids == team_ids

src/backend/core/tests/teams/test_core_api_teams_retrieve.py

@@ -69,8 +69,8 @@ def test_api_teams_retrieve_authenticated_related():
     assert response.json() == {
         "id": str(team.id),
         "name": team.name,
-        "slug": team.slug,
         "abilities": team.get_abilities(user),
         "created_at": team.created_at.isoformat().replace("+00:00", "Z"),
         "updated_at": team.updated_at.isoformat().replace("+00:00", "Z"),
+        "service_providers": [],
     }

src/backend/core/tests/teams/test_core_api_teams_update.py

@@ -7,7 +7,6 @@ import random
 import pytest
 from rest_framework.status import (
     HTTP_200_OK,
-    HTTP_400_BAD_REQUEST,
     HTTP_401_UNAUTHORIZED,
     HTTP_403_FORBIDDEN,
     HTTP_404_NOT_FOUND,
@@ -15,7 +14,7 @@ from rest_framework.status import (
 from rest_framework.test import APIClient
 
 from core import factories
-from core.api import serializers
+from core.api.client import serializers
 
 pytestmark = pytest.mark.django_db
 
@@ -125,7 +124,7 @@ def test_api_teams_update_authenticated_administrators():
         elif key == "updated_at":
             assert value > initial_values[key]
         else:
-            # name, slug and abilities successfully modified
+            # name and abilities successfully modified
             assert value == new_values[key]
 
 
@@ -158,7 +157,7 @@ def test_api_teams_update_authenticated_owners():
         elif key == "updated_at":
             assert value > old_team_values[key]
         else:
-            # name, slug and abilities successfully modified
+            # name and abilities successfully modified
             assert value == new_team_values[key]
 
 
@@ -191,29 +190,32 @@ def test_api_teams_update_administrator_or_owner_of_another():
     assert team_values == old_team_values
 
 
-def test_api_teams_update_existing_slug_should_return_error():
+def test_api_teams_update_authenticated_owners_add_service_providers():
     """
-    Updating a team's name to an existing slug should return a bad request,
-    instead of creating a duplicate.
+    Owners of a team should be allowed to update its service providers.
     """
     user = factories.UserFactory()
 
     client = APIClient()
     client.force_login(user)
 
-    factories.TeamFactory(name="Existing team", users=[(user, "administrator")])
-    my_team = factories.TeamFactory(name="New team", users=[(user, "administrator")])
+    team = factories.TeamFactory(users=[(user, "owner")])
+    new_team_values = serializers.TeamSerializer(instance=team).data
+
+    service_provider_1 = factories.ServiceProviderFactory()
+    service_provider_2 = factories.ServiceProviderFactory()
+    new_team_values["service_providers"] = [
+        service_provider_1.pk,
+        service_provider_2.pk,
+    ]
 
-    updated_values = serializers.TeamSerializer(instance=my_team).data
-    # Update my team's name for existing team. Creates a duplicate slug
-    updated_values["name"] = "existing team"
     response = client.put(
-        f"/api/v1.0/teams/{my_team.id!s}/",
-        updated_values,
+        f"/api/v1.0/teams/{team.id!s}/",
+        new_team_values,
         format="json",
     )
-    assert response.status_code == HTTP_400_BAD_REQUEST
-    assert response.json()["slug"] == ["Team with this Slug already exists."]
-    # Both teams names and slugs should be unchanged
-    assert my_team.name == "New team"
-    assert my_team.slug == "new-team"
+    assert response.status_code == HTTP_200_OK
+
+    team.refresh_from_db()
+    assert team.service_providers.count() == 2
+    assert set(team.service_providers.all()) == {service_provider_1, service_provider_2}

src/backend/core/tests/test_api_config.py

@@ -20,7 +20,14 @@ def test_api_config_anonymous():
     assert response.status_code == HTTP_200_OK
     assert response.json() == {
         "LANGUAGES": [["en-us", "English"], ["fr-fr", "French"]],
-        "FEATURES": {"TEAMS": True},
+        "COMMIT": "NA",
+        "FEATURES": {
+            "CONTACTS_DISPLAY": True,
+            "CONTACTS_CREATE": True,
+            "MAILBOXES_CREATE": True,
+            "TEAMS_DISPLAY": True,
+            "TEAMS_CREATE": True,
+        },
         "RELEASE": "NA",
     }
 
@@ -36,6 +43,13 @@ def test_api_config_authenticated():
     assert response.status_code == HTTP_200_OK
     assert response.json() == {
         "LANGUAGES": [["en-us", "English"], ["fr-fr", "French"]],
-        "FEATURES": {"TEAMS": True},
+        "COMMIT": "NA",
+        "FEATURES": {
+            "CONTACTS_DISPLAY": True,
+            "CONTACTS_CREATE": True,
+            "MAILBOXES_CREATE": True,
+            "TEAMS_DISPLAY": True,
+            "TEAMS_CREATE": True,
+        },
         "RELEASE": "NA",
     }

src/backend/core/tests/test_api_contacts.py

@@ -8,7 +8,7 @@ import pytest
 from rest_framework.test import APIClient
 
 from core import factories, models
-from core.api import serializers
+from core.api.client import serializers
 
 pytestmark = pytest.mark.django_db
 
@@ -131,19 +131,17 @@ def test_api_contacts_list_authenticated_by_full_name():
     contact_ids = [contact["id"] for contact in response.json()]
     assert contact_ids == [str(frank.id)]
 
-    # Result that matches a trigram twice ranks better than result that matches once
     response = client.get("/api/v1.0/contacts/?q=ole")
 
     assert response.status_code == 200
     contact_ids = [contact["id"] for contact in response.json()]
-    # "Nicole Foole" matches twice on "ole"
-    assert contact_ids == [str(nicole.id), str(frank.id)]
+    assert contact_ids == [str(frank.id), str(nicole.id)]
 
     response = client.get("/api/v1.0/contacts/?q=ool")
 
     assert response.status_code == 200
     contact_ids = [contact["id"] for contact in response.json()]
-    assert contact_ids == [str(nicole.id), str(frank.id)]
+    assert contact_ids == [str(frank.id), str(nicole.id)]
 
 
 def test_api_contacts_list_authenticated_uppercase_content():

src/backend/core/tests/test_api_team_invitations.py

@@ -9,7 +9,7 @@ from rest_framework import status
 from rest_framework.test import APIClient
 
 from core import factories
-from core.api import serializers
+from core.api.client import serializers
 
 pytestmark = pytest.mark.django_db
 

src/backend/core/tests/test_api_users.py

@@ -14,8 +14,11 @@ from rest_framework.status import (
 from rest_framework.test import APIClient
 
 from core import factories, models
-from core.api import serializers
-from core.api.viewsets import Pagination
+from core.api.client import serializers
+from core.api.client.viewsets import Pagination
+from core.factories import TeamAccessFactory
+
+from mailbox_manager.factories import MailDomainAccessFactory
 
 pytestmark = pytest.mark.django_db
 
@@ -48,6 +51,73 @@ def test_api_users_list_authenticated():
     assert len(response.json()["results"]) == 3
 
 
+def test_api_users_list_authenticated_response_content(
+    client, django_assert_num_queries
+):
+    """
+    Authenticated users should be able to list all users with the expected output.
+    """
+    user_organization = factories.OrganizationFactory(
+        with_registration_id=True, name="HAL 9000"
+    )
+    user = factories.UserFactory(
+        organization=user_organization,
+        email="kylefields@example.net",
+        name="Mr. Christopher Curtis",
+        language="en-us",
+    )
+
+    client.force_login(user)
+
+    other_user_organization = factories.OrganizationFactory(
+        with_registration_id=True, name="Corp. Inc."
+    )
+    other_user = factories.UserFactory(
+        organization=other_user_organization,
+        email="sara83@example.com",
+        name="Christopher Thompson",
+        language="fr-fr",
+    )
+
+    with django_assert_num_queries(3):  # get User, Count, Users
+        response = client.get("/api/v1.0/users/")
+
+    assert response.status_code == HTTP_200_OK
+    assert response.json() == {
+        "count": 2,
+        "next": None,
+        "previous": None,
+        "results": [
+            {
+                "email": "sara83@example.com",
+                "id": str(other_user.pk),
+                "is_device": False,
+                "is_staff": False,
+                "language": "fr-fr",
+                "name": "Christopher Thompson",
+                "organization": {
+                    "id": str(other_user.organization.pk),
+                    "name": "Corp. Inc.",
+                },
+                "timezone": "UTC",
+            },
+            {
+                "email": "kylefields@example.net",
+                "id": str(user.pk),
+                "is_device": False,
+                "is_staff": False,
+                "language": "en-us",
+                "name": "Mr. Christopher Curtis",
+                "organization": {
+                    "id": str(user.organization.pk),
+                    "name": "HAL 9000",
+                },
+                "timezone": "UTC",
+            },
+        ],
+    }
+
+
 def test_api_users_authenticated_list_by_email():
     """
     Authenticated users should be able to search users with a case-insensitive and
@@ -55,8 +125,12 @@ def test_api_users_authenticated_list_by_email():
     """
     user = factories.UserFactory(email="tester@ministry.fr", name="john doe")
     dave = factories.UserFactory(email="david.bowman@work.com", name=None)
-    nicole = factories.UserFactory(email="nicole_foole@work.com", name=None)
-    frank = factories.UserFactory(email="frank_poole@work.com", name=None)
+    nicole = factories.UserFactory(
+        email="nicole_foole@work.com", name=None, with_organization=True
+    )
+    frank = factories.UserFactory(
+        email="frank_poole@work.com", name=None, with_organization=True
+    )
     factories.UserFactory(email="heywood_floyd@work.com", name=None)
 
     client = APIClient()
@@ -78,28 +152,16 @@ def test_api_users_authenticated_list_by_email():
     user_ids = [user["id"] for user in response.json()["results"]]
     assert user_ids[0] == str(frank.id)
 
-    # Result that matches a trigram twice ranks better than result that matches once
     response = client.get("/api/v1.0/users/?q=ole")
 
     assert response.status_code == HTTP_200_OK
     user_ids = [user["id"] for user in response.json()["results"]]
-    # "Nicole Foole" matches twice on "ole"
-    assert user_ids == [str(nicole.id), str(frank.id)]
+    assert user_ids == [str(frank.id), str(nicole.id)]
 
-    # Even with a low similarity threshold, query should match expected emails
     response = client.get("/api/v1.0/users/?q=ool")
 
     assert response.status_code == HTTP_200_OK
     assert response.json()["results"] == [
-        {
-            "id": str(nicole.id),
-            "email": nicole.email,
-            "name": nicole.name,
-            "is_device": nicole.is_device,
-            "is_staff": nicole.is_staff,
-            "language": nicole.language,
-            "timezone": str(nicole.timezone),
-        },
         {
             "id": str(frank.id),
             "email": frank.email,
@@ -108,6 +170,23 @@ def test_api_users_authenticated_list_by_email():
             "is_staff": frank.is_staff,
             "language": frank.language,
             "timezone": str(frank.timezone),
+            "organization": {
+                "id": str(frank.organization.pk),
+                "name": frank.organization.name,
+            },
+        },
+        {
+            "id": str(nicole.id),
+            "email": nicole.email,
+            "name": nicole.name,
+            "is_device": nicole.is_device,
+            "is_staff": nicole.is_staff,
+            "language": nicole.language,
+            "timezone": str(nicole.timezone),
+            "organization": {
+                "id": str(nicole.organization.pk),
+                "name": nicole.organization.name,
+            },
         },
     ]
 
@@ -118,9 +197,13 @@ def test_api_users_authenticated_list_by_name():
     partial query on the name.
     """
     user = factories.UserFactory(email="tester@ministry.fr", name="john doe")
-    dave = factories.UserFactory(name="dave bowman", email=None)
-    nicole = factories.UserFactory(name="nicole foole", email=None)
-    frank = factories.UserFactory(name="frank poole", email=None)
+    dave = factories.UserFactory(name="Dave bowman", email=None)
+    nicole = factories.UserFactory(
+        name="nicole foole", email=None, with_organization=True
+    )
+    frank = factories.UserFactory(
+        name="frank poolé", email=None, with_organization=True
+    )
     factories.UserFactory(name="heywood floyd", email=None)
 
     client = APIClient()
@@ -128,7 +211,7 @@ def test_api_users_authenticated_list_by_name():
 
     # Full query should work
     response = client.get(
-        "/api/v1.0/users/?q=david.bowman@work.com",
+        "/api/v1.0/users/?q=dave",
     )
 
     assert response.status_code == HTTP_200_OK
@@ -142,28 +225,16 @@ def test_api_users_authenticated_list_by_name():
     user_ids = [user["id"] for user in response.json()["results"]]
     assert user_ids[0] == str(frank.id)
 
-    # Result that matches a trigram twice ranks better than result that matches once
     response = client.get("/api/v1.0/users/?q=ole")
 
     assert response.status_code == HTTP_200_OK
     user_ids = [user["id"] for user in response.json()["results"]]
-    # "Nicole Foole" matches twice on "ole"
-    assert user_ids == [str(nicole.id), str(frank.id)]
+    assert user_ids == [str(frank.id), str(nicole.id)]
 
-    # Even with a low similarity threshold, query should match expected user
-    response = client.get("/api/v1.0/users/?q=ool")
+    response = client.get("/api/v1.0/users/?q=oole")
 
     assert response.status_code == HTTP_200_OK
     assert response.json()["results"] == [
-        {
-            "id": str(nicole.id),
-            "email": nicole.email,
-            "name": nicole.name,
-            "is_device": nicole.is_device,
-            "is_staff": nicole.is_staff,
-            "language": nicole.language,
-            "timezone": str(nicole.timezone),
-        },
         {
             "id": str(frank.id),
             "email": frank.email,
@@ -172,6 +243,23 @@ def test_api_users_authenticated_list_by_name():
             "is_staff": frank.is_staff,
             "language": frank.language,
             "timezone": str(frank.timezone),
+            "organization": {
+                "id": str(frank.organization.pk),
+                "name": frank.organization.name,
+            },
+        },
+        {
+            "id": str(nicole.id),
+            "email": nicole.email,
+            "name": nicole.name,
+            "is_device": nicole.is_device,
+            "is_staff": nicole.is_staff,
+            "language": nicole.language,
+            "timezone": str(nicole.timezone),
+            "organization": {
+                "id": str(nicole.organization.pk),
+                "name": nicole.organization.name,
+            },
         },
     ]
 
@@ -184,22 +272,18 @@ def test_api_users_authenticated_list_by_name_and_email():
 
     user = factories.UserFactory(email="tester@ministry.fr", name="john doe")
     nicole = factories.UserFactory(email="nicole_foole@work.com", name="nicole foole")
-    frank = factories.UserFactory(email="oleg_poole@work.com", name=None)
+    oleg = factories.UserFactory(email="oleg_poole@work.com", name=None)
     david = factories.UserFactory(email=None, name="david role")
 
     client = APIClient()
     client.force_login(user)
 
-    # Result that matches a trigram in name and email ranks better than result that matches once
     response = client.get("/api/v1.0/users/?q=ole")
 
     assert response.status_code == HTTP_200_OK
     user_ids = [user["id"] for user in response.json()["results"]]
 
-    # "Nicole Foole" matches twice on "ole" in her name and twice on "ole" in her email
-    # "Oleg poole" matches twice on "ole" in her email
-    # "David role" matches once on "ole" in his name
-    assert user_ids == [str(nicole.id), str(frank.id), str(david.id)]
+    assert user_ids == [str(david.id), str(oleg.id), str(nicole.id)]
 
 
 def test_api_users_authenticated_list_exclude_users_already_in_team(
@@ -444,7 +528,7 @@ def test_api_users_retrieve_me_anonymous():
 
 def test_api_users_retrieve_me_authenticated():
     """Authenticated users should be able to retrieve their own user via the "/users/me" path."""
-    user = factories.UserFactory()
+    user = factories.UserFactory(with_organization=True)
 
     client = APIClient()
     client.force_login(user)
@@ -468,6 +552,81 @@ def test_api_users_retrieve_me_authenticated():
         "timezone": str(user.timezone),
         "is_device": False,
         "is_staff": False,
+        "abilities": {
+            "contacts": {"can_create": True, "can_view": True},
+            "mailboxes": {"can_create": False, "can_view": False},
+            "teams": {"can_create": False, "can_view": False},
+        },
+        "organization": {
+            "id": str(user.organization.pk),
+            "name": user.organization.name,
+        },
+    }
+
+
+def test_api_users_retrieve_me_authenticated_abilities():
+    """
+    Authenticated users should be able to retrieve their own user via the "/users/me" path
+    with the proper abilities.
+    """
+    user = factories.UserFactory()
+
+    client = APIClient()
+    client.force_login(user)
+
+    # Define profile contact
+    contact = factories.ContactFactory(owner=user)
+    user.profile_contact = contact
+    user.save()
+
+    factories.UserFactory.create_batch(2)
+
+    # Test the mailboxes abilities
+    mail_domain_access = MailDomainAccessFactory(user=user)
+
+    response = client.get("/api/v1.0/users/me/")
+
+    assert response.status_code == HTTP_200_OK
+    assert response.json()["abilities"] == {
+        "contacts": {"can_create": True, "can_view": True},
+        "mailboxes": {"can_create": True, "can_view": True},
+        "teams": {"can_create": False, "can_view": False},
+    }
+
+    # Test the teams abilities - user is not an admin/owner
+    team_access = TeamAccessFactory(user=user, role=models.RoleChoices.MEMBER)
+    response = client.get("/api/v1.0/users/me/")
+
+    assert response.status_code == HTTP_200_OK
+    assert response.json()["abilities"] == {
+        "contacts": {"can_create": True, "can_view": True},
+        "mailboxes": {"can_create": True, "can_view": True},
+        "teams": {"can_create": False, "can_view": False},
+    }
+
+    # Test the teams abilities - user is an admin/owner
+    team_access.role = models.RoleChoices.ADMIN
+    team_access.save()
+
+    response = client.get("/api/v1.0/users/me/")
+
+    assert response.status_code == HTTP_200_OK
+    assert response.json()["abilities"] == {
+        "contacts": {"can_create": True, "can_view": True},
+        "mailboxes": {"can_create": True, "can_view": True},
+        "teams": {"can_create": True, "can_view": True},
+    }
+
+    # Test the mailboxes abilities - user has no mail domain access anymore
+    mail_domain_access.delete()
+
+    response = client.get("/api/v1.0/users/me/")
+
+    assert response.status_code == HTTP_200_OK
+    assert response.json()["abilities"] == {
+        "contacts": {"can_create": True, "can_view": True},
+        "mailboxes": {"can_create": False, "can_view": False},
+        "teams": {"can_create": True, "can_view": True},
     }
 
 

src/backend/core/tests/test_models_organizations.py

@@ -0,0 +1,127 @@
+"""
+Unit tests for the Organization model
+"""
+
+from django.core.exceptions import ValidationError
+
+import pytest
+
+from core import factories, models
+
+pytestmark = pytest.mark.django_db
+
+
+def test_models_organization_str():
+    """The str representation should be the organization's name."""
+    organization = factories.OrganizationFactory(
+        name="HAL 9000", registration_id_list=["12345678901234"]
+    )
+    assert str(organization) == f"HAL 9000 (# {organization.pk})"
+
+
+def test_models_organization_constraints():
+    """It should not be possible to create an organization."""
+    organization = factories.OrganizationFactory(
+        registration_id_list=["12345678901234"], domain_list=["hal9000.com"]
+    )
+
+    with pytest.raises(ValidationError):
+        models.Organization.objects.create(name="HAL 9000")
+
+    with pytest.raises(ValidationError):
+        models.Organization.objects.create(
+            name="HAL 9000",
+            registration_id_list=[
+                organization.registration_id_list[0],
+                "12345678901235",
+            ],
+        )
+
+    with pytest.raises(ValidationError):
+        models.Organization.objects.create(
+            name="HAL 9000", domain_list=[organization.domain_list[0], "hal9001.com"]
+        )
+
+
+def test_models_organization_get_or_create_from_user_claims_no_kwargs():
+    """It should fail."""
+    with pytest.raises(ValueError):
+        models.Organization.objects.get_or_create_from_user_claims()
+
+
+def test_models_organization_get_or_create_from_user_claims_with_registration_id():
+    """It should create an organization with a registration ID number."""
+    organization, created = models.Organization.objects.get_or_create_from_user_claims(
+        registration_id="12345678901234"
+    )
+    assert created is True
+    assert organization.registration_id_list == ["12345678901234"]
+    assert organization.domain_list == []
+
+    same_organization, created = (
+        models.Organization.objects.get_or_create_from_user_claims(
+            registration_id="12345678901234"
+        )
+    )
+    assert created is False
+    assert organization == same_organization
+    assert same_organization.registration_id_list == ["12345678901234"]
+    assert same_organization.domain_list == []
+
+
+def test_models_organization_get_or_create_from_user_claims_with_domain():
+    """It should create an organization with a domain."""
+    organization, created = models.Organization.objects.get_or_create_from_user_claims(
+        domain="hal9000.com"
+    )
+    assert created is True
+    assert organization.registration_id_list == []
+    assert organization.domain_list == ["hal9000.com"]
+
+    same_organization, created = (
+        models.Organization.objects.get_or_create_from_user_claims(domain="hal9000.com")
+    )
+    assert created is False
+    assert organization == same_organization
+    assert same_organization.registration_id_list == []
+    assert same_organization.domain_list == ["hal9000.com"]
+
+
+def test_models_organization_get_or_create_from_user_claims_with_registration_id_and_domain():
+    """It should create an organization with a registration ID number."""
+    organization, created = models.Organization.objects.get_or_create_from_user_claims(
+        registration_id="12345678901234", domain="hal9000.com"
+    )
+    assert created is True
+    assert organization.registration_id_list == ["12345678901234"]
+    assert organization.domain_list == []
+
+    same_organization, created = (
+        models.Organization.objects.get_or_create_from_user_claims(
+            registration_id="12345678901234", domain="hal9000.com"
+        )
+    )
+    assert created is False
+    assert organization == same_organization
+    assert same_organization.registration_id_list == ["12345678901234"]
+    assert same_organization.domain_list == []
+
+
+def test_models_organization_registration_id_validators():
+    """
+    Test the registration ID validators.
+
+    This cannot be tested dynamically because the validators are set at model loading
+    and this is not possible to reload the models on the fly. We therefore enforce the
+    setting in Test environment.
+    """
+    models.Organization.objects.create(
+        name="hu",
+        registration_id_list=["12345678901234"],
+    )
+
+    with pytest.raises(ValidationError):
+        models.Organization.objects.create(
+            name="hi",
+            registration_id_list=["a12345678912345"],
+        )

src/backend/core/tests/test_models_teams.py

@@ -47,12 +47,6 @@ def test_models_teams_name_max_length():
         factories.TeamFactory(name="a " * 51)
 
 
-def test_models_teams_slug_empty():
-    """Slug field should not be empty."""
-    with pytest.raises(ValidationError, match="This field cannot be blank."):
-        models.Team.objects.create(slug="")
-
-
 # get_abilities
 
 

src/backend/core/tests/test_validators.py

@@ -0,0 +1,58 @@
+"""
+Test cases for core.validators module.
+"""
+
+from django.core.exceptions import ImproperlyConfigured
+from django.core.validators import EmailValidator, RegexValidator
+
+import pytest
+
+from core.validators import get_field_validators_from_setting
+
+
+def test_get_field_validators_from_setting_without_option(settings):
+    """Test get_field_validators_from_setting without options."""
+    settings.VALIDATOR_NO_OPTION = [
+        {
+            "NAME": "django.core.validators.EmailValidator",
+        },
+    ]
+
+    validators = get_field_validators_from_setting("VALIDATOR_NO_OPTION")
+    assert len(validators) == 1
+    assert isinstance(validators[0], EmailValidator)
+
+
+def test_get_field_validators_from_setting_with_option(settings):
+    """Test get_field_validators_from_setting with options."""
+    settings.REGEX_WITH_OPTIONS = [
+        {
+            "NAME": "django.core.validators.RegexValidator",
+            "OPTIONS": {
+                "regex": "[a-z][0-9]{14}",
+            },
+        },
+    ]
+
+    validators = get_field_validators_from_setting("REGEX_WITH_OPTIONS")
+    assert len(validators) == 1
+    assert isinstance(validators[0], RegexValidator)
+    assert validators[0].regex.pattern == "[a-z][0-9]{14}"
+
+
+def test_get_field_validators_from_setting_invalid_class_name(settings):
+    """Test get_field_validators_from_setting with an invalid class name."""
+    settings.INVALID_VALIDATORS = [
+        {
+            "NAME": "non.existent.Validator",
+        },
+    ]
+    with pytest.raises(ImproperlyConfigured):
+        get_field_validators_from_setting("INVALID_VALIDATORS")
+
+
+def test_get_field_validators_from_setting_empty_setting(settings):
+    """Test get_field_validators_from_setting with an empty setting."""
+    settings.EMPTY_VALIDATORS = []
+    validators = get_field_validators_from_setting("EMPTY_VALIDATORS")
+    assert not validators

src/backend/core/utils/__init__.py

@@ -0,0 +1 @@
+"""Core utils module."""

src/backend/core/validators.py

@@ -0,0 +1,41 @@
+"""
+Declare validators that can be used in our Django models.
+"""
+
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
+from django.utils.module_loading import import_string
+
+
+def get_field_validators_from_setting(setting_name: str) -> list:
+    """
+    Get field validators from a setting.
+
+    Highly inspired by Django's `get_password_validators` function.
+
+    The setting should be a list of dictionaries, where each dictionary
+    should have a NAME key that points to the validator class and an
+    optional OPTIONS key that points to the validator options.
+
+    Example:
+    ```
+    ORGANIZATION_REGISTRATION_ID_VALIDATORS = [
+        {
+            "NAME": "django.core.validators.RegexValidator",
+            "OPTIONS": {
+                "regex": "[a-z][0-9]{14}",
+            },
+        },
+    ]
+    ```
+    """
+    validators = []
+    for validator in getattr(settings, setting_name):
+        try:
+            klass = import_string(validator["NAME"])
+        except ImportError as exc:
+            msg = "The module in NAME could not be imported: %s. Check your %s setting."
+            raise ImproperlyConfigured(msg % (validator["NAME"], setting_name)) from exc
+        validators.append(klass(**validator.get("OPTIONS", {})))
+
+    return validators

src/backend/debug/views.py

@@ -33,6 +33,7 @@ class DebugViewNewMailboxHtml(DebugBaseView):
     template_name = "mail/html/new_mailbox.html"
 
     def get_context_data(self, **kwargs):
+        """Hardcode user credentials for debug setting."""
         context = super().get_context_data(**kwargs)
         context["mailbox_data"] = {
             "email": "john.doe@example.com",

src/backend/demo/__init__.py

@@ -0,0 +1 @@
+"""Demo module."""

src/backend/demo/management/__init__.py

@@ -0,0 +1 @@
+"""Demo management module."""

src/backend/demo/management/commands/__init__.py

@@ -0,0 +1 @@
+"Demo management commands module."

src/backend/demo/management/commands/create_demo.py

@@ -106,7 +106,7 @@ class Timeit:
         return elapsed_time
 
 
-def create_demo(stdout):
+def create_demo(stdout):  # pylint: disable=too-many-locals
     """
     Create a database with demo data for developers to work in a realistic environment.
     The code is engineered to create a huge number of objects fast.
@@ -128,6 +128,45 @@ def create_demo(stdout):
                     language=random.choice(settings.LANGUAGES)[0],
                 )
             )
+        # this is a quick fix to fix e2e tests
+        # tests needs some no random data
+        queue.push(
+            models.User(
+                sub=uuid4(),
+                email="monique.test@example.com",
+                name="Monique Test",
+                password="!",
+                is_superuser=False,
+                is_active=True,
+                is_staff=False,
+                language=random.choice(settings.LANGUAGES)[0],
+            )
+        )
+        queue.push(
+            models.User(
+                sub=uuid4(),
+                email="jeanne.test@example.com",
+                name="Jean Test",
+                password="!",
+                is_superuser=False,
+                is_active=True,
+                is_staff=False,
+                language=random.choice(settings.LANGUAGES)[0],
+            )
+        )
+        queue.push(
+            models.User(
+                sub=uuid4(),
+                email="jean.somethingelse@example.com",
+                name="Jean Something",
+                password="!",
+                is_superuser=False,
+                is_active=True,
+                is_staff=False,
+                language=random.choice(settings.LANGUAGES)[0],
+            )
+        )
+
         queue.flush()
 
     with Timeit(stdout, "Creating teams"):
@@ -135,8 +174,6 @@ def create_demo(stdout):
             queue.push(
                 models.Team(
                     name=f"Team {i:d}",
-                    # slug should be automatic but bulk_create doesn't use save
-                    slug=f"team-{i:d}",
                 )
             )
         queue.flush()
@@ -153,11 +190,15 @@ def create_demo(stdout):
                 queue.push(
                     models.TeamAccess(team_id=team_id, user_id=user_id, role=role[0])
                 )
-        queue.flush()
 
     with Timeit(stdout, "Creating domains"):
+        created = set()
         for _i in range(defaults.NB_OBJECTS["domains"]):
             name = fake.domain_name()
+            if name in created:
+                continue
+            created.add(name)
+
             slug = slugify(name)
 
             queue.push(
@@ -182,6 +223,75 @@ def create_demo(stdout):
                     role=models.RoleChoices.OWNER,
                 )
             )
+
+        queue.flush()
+
+    with Timeit(stdout, "Creating specific users"):
+        # ⚠️ Warning: this users also need to be created in the keycloak
+        # realm.json AND the OIDC setting to fallback on user email
+        # should be set to True, because we don't pilot the sub.
+        for role in models.RoleChoices.values:
+            team_user = models.User(
+                sub=uuid4(),
+                email=f"jean.team-{role}@example.com",
+                name=f"Jean Group {role.capitalize()}",
+                password="!",
+                is_superuser=False,
+                is_active=True,
+                is_staff=False,
+                language=random.choice(settings.LANGUAGES)[0],
+            )
+            queue.push(team_user)
+            queue.push(
+                models.TeamAccess(team_id=teams_ids[0], user_id=team_user.pk, role=role)
+            )
+
+        for role in models.RoleChoices.values:
+            user_with_mail = models.User(
+                sub=uuid4(),
+                email=f"jean.mail-{role}@example.com",
+                name=f"Jean Mail {role.capitalize()}",
+                password="!",
+                is_superuser=False,
+                is_active=True,
+                is_staff=False,
+                language=random.choice(settings.LANGUAGES)[0],
+            )
+            queue.push(user_with_mail)
+            queue.push(
+                mailbox_models.MailDomainAccess(
+                    domain_id=domains_ids[0],
+                    user_id=user_with_mail.pk,
+                    role=role,
+                )
+            )
+
+        for team_role in models.RoleChoices.values:
+            for domain_role in models.RoleChoices.values:
+                team_mail_user = models.User(
+                    sub=uuid4(),
+                    email=f"jean.team-{team_role}-mail-{domain_role}@example.com",
+                    name=f"Jean Group {team_role.capitalize()} Mail {domain_role.capitalize()}",
+                    password="!",
+                    is_superuser=False,
+                    is_active=True,
+                    is_staff=False,
+                    language=random.choice(settings.LANGUAGES)[0],
+                )
+                queue.push(team_mail_user)
+                queue.push(
+                    models.TeamAccess(
+                        team_id=teams_ids[0], user_id=team_mail_user.pk, role=team_role
+                    )
+                )
+                queue.push(
+                    mailbox_models.MailDomainAccess(
+                        domain_id=domains_ids[0],
+                        user_id=team_mail_user.pk,
+                        role=domain_role,
+                    )
+                )
+
         queue.flush()
 
 

src/backend/demo/tests/__init__.py

@@ -0,0 +1 @@
+"""Demo tests."""

src/backend/demo/tests/test_commands_create_demo.py

@@ -28,11 +28,22 @@ def test_commands_create_demo():
     """The create_demo management command should create objects as expected."""
     call_command("create_demo")
 
-    assert models.User.objects.count() == TEST_NB_OBJECTS["users"]
+    # Monique Test, Jeanne Test and Jean Something (quick fix for e2e)
+    # 3 user with team rights
+    # 3 user with domain rights
+    # 3 x 3 user with both rights
+    assert models.User.objects.count() == TEST_NB_OBJECTS["users"] + 3 + 3 + 3 + 9
+
     assert models.Team.objects.count() == TEST_NB_OBJECTS["teams"]
     assert models.TeamAccess.objects.count() >= TEST_NB_OBJECTS["teams"]
     assert mailbox_models.MailDomain.objects.count() == TEST_NB_OBJECTS["domains"]
-    assert mailbox_models.MailDomainAccess.objects.count() == TEST_NB_OBJECTS["domains"]
+
+    # 3 domain access for each user with domain rights
+    # 3 x 3 domain access for each user with both rights
+    assert (
+        mailbox_models.MailDomainAccess.objects.count()
+        == TEST_NB_OBJECTS["domains"] + 3 + 9
+    )
 
 
 def test_commands_createsuperuser():

src/backend/locale/fr_FR/LC_MESSAGES/django.po

@@ -2,7 +2,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: lasuite-people\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2024-10-15 10:52+0000\n"
+"POT-Creation-Date: 2024-11-18 23:02+0000\n"
 "PO-Revision-Date: 2024-01-03 23:15\n"
 "Last-Translator: \n"
 "Language-Team: French\n"
@@ -17,225 +17,261 @@ msgstr ""
 "X-Crowdin-File: backend.pot\n"
 "X-Crowdin-File-ID: 2\n"
 
-#: core/admin.py:45
+#: core/admin.py:55
 msgid "Personal info"
 msgstr ""
 
-#: core/admin.py:47
+#: core/admin.py:57
 msgid "Permissions"
 msgstr ""
 
-#: core/admin.py:59
+#: core/admin.py:69
 msgid "Important dates"
 msgstr ""
 
-#: core/admin.py:97
+#: core/admin.py:108
 msgid "User"
 msgstr ""
 
-#: core/authentication/backends.py:82
+#: core/authentication/backends.py:89
 msgid "User info contained no recognizable user identification"
 msgstr ""
 
-#: core/authentication/backends.py:90
+#: core/authentication/backends.py:111
 msgid "User account is disabled"
 msgstr ""
 
-#: core/authentication/backends.py:102
+#: core/authentication/backends.py:157
 msgid "Claims contained no recognizable user identification"
 msgstr ""
 
+#: core/authentication/backends.py:176
+msgid "Claims contained no recognizable organization identification"
+msgstr ""
+
 #: core/enums.py:23
 msgid "Failure"
 msgstr ""
 
-#: core/enums.py:24 mailbox_manager/enums.py:20
+#: core/enums.py:24 mailbox_manager/enums.py:21 mailbox_manager/enums.py:30
 msgid "Pending"
-msgstr ""
+msgstr "En attente"
 
 #: core/enums.py:25
 msgid "Success"
 msgstr ""
 
-#: core/models.py:42
+#: core/models.py:46
 msgid "Member"
 msgstr ""
 
-#: core/models.py:43 mailbox_manager/enums.py:13
+#: core/models.py:47 core/models.py:59 mailbox_manager/enums.py:14
 msgid "Administrator"
 msgstr ""
 
-#: core/models.py:44 mailbox_manager/enums.py:14
+#: core/models.py:48 mailbox_manager/enums.py:15
 msgid "Owner"
 msgstr ""
 
-#: core/models.py:56
+#: core/models.py:71
 msgid "id"
 msgstr ""
 
-#: core/models.py:57
+#: core/models.py:72
 msgid "primary key for the record as UUID"
 msgstr ""
 
-#: core/models.py:63
+#: core/models.py:78
 msgid "created at"
 msgstr ""
 
-#: core/models.py:64
+#: core/models.py:79
 msgid "date and time at which a record was created"
 msgstr ""
 
-#: core/models.py:69
+#: core/models.py:84
 msgid "updated at"
 msgstr ""
 
-#: core/models.py:70
+#: core/models.py:85
 msgid "date and time at which a record was last updated"
 msgstr ""
 
-#: core/models.py:101
+#: core/models.py:116
 msgid "full name"
 msgstr ""
 
-#: core/models.py:102
+#: core/models.py:117
 msgid "short name"
 msgstr ""
 
-#: core/models.py:107
+#: core/models.py:122
 msgid "contact information"
 msgstr ""
 
-#: core/models.py:108
+#: core/models.py:123
 msgid "A JSON object containing the contact information"
 msgstr ""
 
-#: core/models.py:122
+#: core/models.py:137
 msgid "contact"
 msgstr ""
 
-#: core/models.py:123
+#: core/models.py:138
 msgid "contacts"
 msgstr ""
 
-#: core/models.py:167
+#: core/models.py:262 core/models.py:331 mailbox_manager/models.py:24
+msgid "name"
+msgstr ""
+
+#: core/models.py:270
+msgid "registration ID list"
+msgstr ""
+
+#: core/models.py:279
+msgid "domain list"
+msgstr ""
+
+#: core/models.py:289
+msgid "organization"
+msgstr ""
+
+#: core/models.py:290
+msgid "organizations"
+msgstr ""
+
+#: core/models.py:297
+msgid "An organization must have at least a registration ID or a domain."
+msgstr ""
+
+#: core/models.py:316
 msgid ""
 "Enter a valid sub. This value may contain only letters, numbers, and @/./+/-/"
 "_ characters."
 msgstr ""
 
-#: core/models.py:173
+#: core/models.py:322
 msgid "sub"
 msgstr ""
 
-#: core/models.py:175
+#: core/models.py:324
 msgid ""
 "Required. 255 characters or fewer. Letters, numbers, and @/./+/-/_ "
 "characters only."
 msgstr ""
 
-#: core/models.py:181 core/models.py:489
+#: core/models.py:330 core/models.py:737
 msgid "email address"
 msgstr ""
 
-#: core/models.py:182 mailbox_manager/models.py:20
-msgid "name"
-msgstr ""
-
-#: core/models.py:194
+#: core/models.py:343
 msgid "language"
 msgstr ""
 
-#: core/models.py:195
+#: core/models.py:344
 msgid "The language in which the user wants to see the interface."
 msgstr ""
 
-#: core/models.py:201
+#: core/models.py:350
 msgid "The timezone in which the user wants to see times."
 msgstr ""
 
-#: core/models.py:204
+#: core/models.py:353
 msgid "device"
 msgstr ""
 
-#: core/models.py:206
+#: core/models.py:355
 msgid "Whether the user is a device or a real user."
 msgstr ""
 
-#: core/models.py:209
+#: core/models.py:358
 msgid "staff status"
 msgstr ""
 
-#: core/models.py:211
+#: core/models.py:360
 msgid "Whether the user can log into this admin site."
 msgstr ""
 
-#: core/models.py:214
+#: core/models.py:363
 msgid "active"
 msgstr ""
 
-#: core/models.py:217
+#: core/models.py:366
 msgid ""
 "Whether this user should be treated as active. Unselect this instead of "
 "deleting accounts."
 msgstr ""
 
-#: core/models.py:229
+#: core/models.py:385
 msgid "user"
 msgstr ""
 
-#: core/models.py:230
+#: core/models.py:386
 msgid "users"
 msgstr ""
 
-#: core/models.py:306
+#: core/models.py:525
+msgid "Organization/user relation"
+msgstr ""
+
+#: core/models.py:526
+msgid "Organization/user relations"
+msgstr ""
+
+#: core/models.py:531
+msgid "This user is already in this organization."
+msgstr ""
+
+#: core/models.py:563
 msgid "Team"
 msgstr ""
 
-#: core/models.py:307
+#: core/models.py:564
 msgid "Teams"
 msgstr ""
 
-#: core/models.py:367
+#: core/models.py:615
 msgid "Team/user relation"
 msgstr ""
 
-#: core/models.py:368
+#: core/models.py:616
 msgid "Team/user relations"
 msgstr ""
 
-#: core/models.py:373
+#: core/models.py:621
 msgid "This user is already in this team."
 msgstr ""
 
-#: core/models.py:462
+#: core/models.py:710
 msgid "url"
 msgstr ""
 
-#: core/models.py:463
+#: core/models.py:711
 msgid "secret"
 msgstr ""
 
-#: core/models.py:472
+#: core/models.py:720
 msgid "Team webhook"
 msgstr ""
 
-#: core/models.py:473
+#: core/models.py:721
 msgid "Team webhooks"
 msgstr ""
 
-#: core/models.py:506
+#: core/models.py:754
 msgid "Team invitation"
 msgstr ""
 
-#: core/models.py:507
+#: core/models.py:755
 msgid "Team invitations"
 msgstr ""
 
-#: core/models.py:532
+#: core/models.py:780
 msgid "This email is already associated to a registered user."
 msgstr ""
 
-#: core/models.py:574 core/models.py:580
+#: core/models.py:822 core/models.py:828
 msgid "Invitation to join Desk!"
 msgstr ""
 
@@ -420,65 +456,80 @@ msgstr "L'équipe de La Suite"
 msgid "This mail has been sent to %(email)s by %(name)s [%(href)s]"
 msgstr ""
 
-#: mailbox_manager/enums.py:12
+#: mailbox_manager/admin.py:12
+msgid "Synchronise from dimail"
+msgstr ""
+
+#: mailbox_manager/admin.py:23
+#, python-brace-format
+msgid "Synchronisation failed for {domain.name} with message: [{err}]"
+msgstr ""
+
+#: mailbox_manager/admin.py:29
+#, python-brace-format
+msgid "Synchronisation succeed for {domain.name}. "
+msgstr ""
+
+#: mailbox_manager/enums.py:13
 msgid "Viewer"
 msgstr ""
 
-#: mailbox_manager/enums.py:21
+#: mailbox_manager/enums.py:22 mailbox_manager/enums.py:31
 msgid "Enabled"
-msgstr ""
+msgstr "Actif"
 
-#: mailbox_manager/enums.py:22
+#: mailbox_manager/enums.py:23 mailbox_manager/enums.py:32
 msgid "Failed"
-msgstr ""
+msgstr "En échec"
 
-#: mailbox_manager/enums.py:23
+#: mailbox_manager/enums.py:24 mailbox_manager/enums.py:33
 msgid "Disabled"
-msgstr ""
+msgstr "Désactivé"
 
-#: mailbox_manager/models.py:31
+#: mailbox_manager/models.py:35
 msgid "Mail domain"
 msgstr ""
 
-#: mailbox_manager/models.py:32
+#: mailbox_manager/models.py:36
 msgid "Mail domains"
 msgstr ""
 
-#: mailbox_manager/models.py:98
+#: mailbox_manager/models.py:102
 msgid "User/mail domain relation"
 msgstr ""
 
-#: mailbox_manager/models.py:99
+#: mailbox_manager/models.py:103
 msgid "User/mail domain relations"
 msgstr ""
 
-#: mailbox_manager/models.py:171
+#: mailbox_manager/models.py:175
 msgid "local_part"
 msgstr ""
 
-#: mailbox_manager/models.py:185
+#: mailbox_manager/models.py:189
 msgid "secondary email address"
 msgstr ""
 
-#: mailbox_manager/models.py:190
+#: mailbox_manager/models.py:199
 msgid "Mailbox"
 msgstr ""
 
-#: mailbox_manager/models.py:191
+#: mailbox_manager/models.py:200
 msgid "Mailboxes"
 msgstr ""
 
-#: mailbox_manager/utils/dimail.py:137
+#: mailbox_manager/models.py:224
+msgid "You can't create or update a mailbox for a disabled domain."
+msgstr "Vous ne pouvez pas créer ou modifier une boîte mail pour un domain désactivé."
+
+#: mailbox_manager/utils/dimail.py:183
 msgid "Your new mailbox information"
 msgstr "Informations concernant votre nouvelle boîte mail"
 
-#: people/settings.py:134
+#: people/settings.py:135
 msgid "English"
 msgstr ""
 
-#: people/settings.py:135
+#: people/settings.py:136
 msgid "French"
 msgstr ""
-
-#~ msgid "Regards,"
-#~ msgstr "Cordialement,"

src/backend/mailbox_manager/__init__.py

@@ -0,0 +1 @@
+"""Mailbox manager module."""

src/backend/mailbox_manager/admin.py

@@ -1,9 +1,35 @@
 """Admin classes and registrations for People's mailbox manager app."""
 
-from django.contrib import admin
+from django.contrib import admin, messages
 from django.utils.translation import gettext_lazy as _
 
+from requests import exceptions
+
 from mailbox_manager import models
+from mailbox_manager.utils.dimail import DimailAPIClient
+
+
+@admin.action(description=_("Synchronise from dimail"))
+def sync_mailboxes_from_dimail(modeladmin, request, queryset):  # pylint: disable=unused-argument
+    """Admin action to synchronize existing mailboxes from dimail to our database."""
+    client = DimailAPIClient()
+
+    for domain in queryset:
+        try:
+            imported_mailboxes = client.import_mailboxes(domain)
+        except exceptions.HTTPError as err:
+            messages.error(
+                request,
+                _(f"Synchronisation failed for {domain.name} with message: [{err}]"),
+            )
+        else:
+            messages.success(
+                request,
+                _(
+                    f"Synchronisation succeed for {domain.name}. "
+                    f"Imported mailboxes: {', '.join(imported_mailboxes)}"
+                ),
+            )
 
 
 class UserMailDomainAccessInline(admin.TabularInline):
@@ -28,6 +54,14 @@ class MailDomainAdmin(admin.ModelAdmin):
     search_fields = ("name",)
     readonly_fields = ["created_at", "slug"]
     inlines = (UserMailDomainAccessInline,)
+    actions = (sync_mailboxes_from_dimail,)
+
+
+@admin.register(models.Mailbox)
+class MailboxAdmin(admin.ModelAdmin):
+    """Admin for mailbox model."""
+
+    list_display = ("__str__", "first_name", "last_name", "status")
 
 
 @admin.register(models.MailDomainAccess)
@@ -50,10 +84,3 @@ class MailDomainAccessInline(admin.TabularInline):
     autocomplete_fields = ["user", "domain"]
     model = models.MailDomainAccess
     readonly_fields = ("created_at", "updated_at")
-
-
-@admin.register(models.Mailbox)
-class MailboxAdmin(admin.ModelAdmin):
-    """Admin for mailbox model."""
-
-    list_display = ("__str__", "first_name", "last_name")

src/backend/mailbox_manager/api/__init__.py

@@ -0,0 +1 @@
+"""Mailbox manager API module."""

src/backend/mailbox_manager/api/client/__init__.py

@@ -0,0 +1 @@
+"""Mailbox manager client API module."""

src/backend/mailbox_manager/api/client/serializers.py

@@ -4,7 +4,7 @@ import json
 
 from rest_framework import exceptions, serializers
 
-from core.api.serializers import UserSerializer
+from core.api.client.serializers import UserSerializer
 from core.models import User
 
 from mailbox_manager import enums, models
@@ -16,32 +16,45 @@ class MailboxSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = models.Mailbox
-        fields = ["id", "first_name", "last_name", "local_part", "secondary_email"]
+        fields = [
+            "id",
+            "first_name",
+            "last_name",
+            "local_part",
+            "secondary_email",
+            "status",
+        ]
         # everything is actually read-only as we do not allow update for now
-        read_only_fields = ["id"]
+        read_only_fields = ["id", "status"]
 
     def create(self, validated_data):
         """
         Override create function to fire a request on mailbox creation.
         """
-        # send new mailbox request to dimail
-        client = DimailAPIClient()
-        response = client.send_mailbox_request(
-            validated_data, self.context["request"].user.sub
-        )
+        mailbox_status = enums.MailDomainStatusChoices.PENDING
 
-        # fix format to have actual json, and remove uuid
-        mailbox_data = json.loads(response.content.decode("utf-8").replace("'", '"'))
-        del mailbox_data["uuid"]
+        if validated_data["domain"].status == enums.MailDomainStatusChoices.ENABLED:
+            client = DimailAPIClient()
+            # send new mailbox request to dimail
+            response = client.create_mailbox(
+                validated_data, self.context["request"].user.sub
+            )
+
+            # fix format to have actual json, and remove uuid
+            mailbox_data = json.loads(
+                response.content.decode("utf-8").replace("'", '"')
+            )
+            del mailbox_data["uuid"]
+
+            mailbox_status = enums.MailDomainStatusChoices.ENABLED
+
+            # send confirmation email
+            client.notify_mailbox_creation(
+                recipient=validated_data["secondary_email"], mailbox_data=mailbox_data
+            )
 
         # actually save mailbox on our database
-        instance = models.Mailbox.objects.create(**validated_data)
-
-        # send confirmation email
-        client.send_new_mailbox_notification(
-            recipient=validated_data["secondary_email"], mailbox_data=mailbox_data
-        )
-        return instance
+        return models.Mailbox.objects.create(**validated_data, status=mailbox_status)
 
 
 class MailDomainSerializer(serializers.ModelSerializer):
@@ -77,6 +90,17 @@ class MailDomainSerializer(serializers.ModelSerializer):
             return domain.get_abilities(request.user)
         return {}
 
+    def create(self, validated_data):
+        """
+        Override create function to fire a request to dimail upon domain creation.
+        """
+        # send new domain request to dimail
+        client = DimailAPIClient()
+        client.create_domain(validated_data["name"], self.context["request"].user.sub)
+
+        # no exception raised ? Then actually save domain on our database
+        return models.MailDomain.objects.create(**validated_data)
+
 
 class MailDomainAccessSerializer(serializers.ModelSerializer):
     """Serialize mail domain access."""

src/backend/mailbox_manager/api/client/viewsets.py

@@ -3,11 +3,15 @@
 from django.db.models import Subquery
 
 from rest_framework import exceptions, filters, mixins, viewsets
+from rest_framework.decorators import action
+from rest_framework.response import Response
 
 from core import models as core_models
 
 from mailbox_manager import enums, models
-from mailbox_manager.api import permissions, serializers
+from mailbox_manager.api import permissions
+from mailbox_manager.api.client import serializers
+from mailbox_manager.utils.dimail import DimailAPIClient
 
 
 # pylint: disable=too-many-ancestors
@@ -40,6 +44,7 @@ class MailDomainViewSet(
     queryset = models.MailDomain.objects.all()
 
     def get_queryset(self):
+        """Restrict results to the current user's team."""
         return self.queryset.filter(accesses__user=self.request.user)
 
     def perform_create(self, serializer):
@@ -100,6 +105,7 @@ class MailDomainAccessViewSet(
     detail_serializer_class = serializers.MailDomainAccessSerializer
 
     def get_serializer_class(self):
+        """Chooses list or detail serializer according to the action."""
         if self.action in {"list", "retrieve"}:
             return self.list_serializer_class
         return self.detail_serializer_class
@@ -183,15 +189,21 @@ class MailBoxViewSet(
 ):
     """MailBox ViewSet
 
-    GET /api/<version>/mail-domains/<domain-slug>/mailboxes/
+    GET /api/<version>/mail-domains/<domain_slug>/mailboxes/
         Return a list of mailboxes on the domain
 
-    POST /api/<version>/mail-domains/<domain-slug>/mailboxes/ with expected data:
+    POST /api/<version>/mail-domains/<domain_slug>/mailboxes/ with expected data:
         - first_name: str
         - last_name: str
         - local_part: str
         - secondary_email: str
         Sends request to email provisioning API and returns newly created mailbox
+
+    POST /api/<version>/mail-domains/<domain_slug>/mailboxes/<mailbox_id>/disable/
+        Send a request to dimail to disable mailbox and change status of the mailbox in our DB
+
+    POST /api/<version>/mail-domains/<domain_slug>/mailboxes/<mailbox_id>/enable/
+        Send a request to dimail to enable mailbox and change status of the mailbox in our DB
     """
 
     permission_classes = [permissions.MailBoxPermission]
@@ -215,3 +227,23 @@ class MailBoxViewSet(
                 slug=domain_slug
             )
         super().perform_create(serializer)
+
+    @action(detail=True, methods=["post"])
+    def disable(self, request, domain_slug, pk=None):  # pylint: disable=unused-argument
+        """Disable mailbox. Send a request to dimail and change status in our DB"""
+        mailbox = self.get_object()
+        client = DimailAPIClient()
+        client.disable_mailbox(mailbox, request.user.sub)
+        mailbox.status = enums.MailboxStatusChoices.DISABLED
+        mailbox.save()
+        return Response(serializers.MailboxSerializer(mailbox).data)
+
+    @action(detail=True, methods=["post"])
+    def enable(self, request, domain_slug, pk=None):  # pylint: disable=unused-argument
+        """Enable mailbox. Send a request to dimail and change status in our DB"""
+        mailbox = self.get_object()
+        client = DimailAPIClient()
+        client.enable_mailbox(mailbox, request.user.sub)
+        mailbox.status = enums.MailboxStatusChoices.ENABLED
+        mailbox.save()
+        return Response(serializers.MailboxSerializer(mailbox).data)

src/backend/mailbox_manager/api/permissions.py

@@ -18,6 +18,7 @@ class MailBoxPermission(core_permissions.IsAuthenticated):
     """Permission class to manage mailboxes for a mail domain"""
 
     def has_permission(self, request, view):
+        """Check permission based on domain."""
         domain = models.MailDomain.objects.get(slug=view.kwargs.get("domain_slug", ""))
         abilities = domain.get_abilities(request.user)
         return abilities.get(request.method.lower(), False)

src/backend/mailbox_manager/enums.py

@@ -1,3 +1,4 @@
+# pylint: disable=too-many-ancestors
 """
 Application enums declaration
 """
@@ -21,3 +22,12 @@ class MailDomainStatusChoices(models.TextChoices):
     ENABLED = "enabled", _("Enabled")
     FAILED = "failed", _("Failed")
     DISABLED = "disabled", _("Disabled")
+
+
+class MailboxStatusChoices(models.TextChoices):
+    """Lists the possible statuses in which a mailbox can be."""
+
+    PENDING = "pending", _("Pending")
+    ENABLED = "enabled", _("Enabled")
+    FAILED = "failed", _("Failed")
+    DISABLED = "disabled", _("Disabled")

src/backend/mailbox_manager/factories.py

@@ -75,3 +75,9 @@ class MailboxFactory(factory.django.DjangoModelFactory):
     )
     domain = factory.SubFactory(MailDomainEnabledFactory)
     secondary_email = factory.Faker("email")
+
+
+class MailboxEnabledFactory(MailboxFactory):
+    """A factory to create mailbox enabled."""
+
+    status = enums.MailboxStatusChoices.ENABLED