diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..ccbfadbd88427d83aa5300487231a0433429e3e9
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+site/
\ No newline at end of file
diff --git a/README.md b/README.md
index bd93c1a6c4879ac5dfe5d523d5652c8c4107be74..4cfe7454071baf4b537cb798adb71c2a1d423c4f 100644
--- a/README.md
+++ b/README.md
@@ -1,93 +1,8 @@
-# Documentation
+# Questions for Andreas
+Localhost on dockerize ACME. How can I get user real IP address?
-## Getting started
-
-To make it easy for you to get started with GitLab, here's a list of recommended next steps.
-
-Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!
-
-## Add your files
-
-- [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
-- [ ] [Add files using the command line](https://docs.gitlab.com/ee/gitlab-basics/add-file.html#add-a-file-using-the-command-line) or push an existing Git repository with the following command:
-
-```
-cd existing_repo
-git remote add origin https://gitlab.inria.fr/act/documentation.git
-git branch -M main
-git push -uf origin main
-```
-
-## Integrate with your tools
-
-- [ ] [Set up project integrations](https://gitlab.inria.fr/act/documentation/-/settings/integrations)
-
-## Collaborate with your team
-
-- [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
-- [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
-- [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
-- [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
-- [ ] [Set auto-merge](https://docs.gitlab.com/ee/user/project/merge_requests/merge_when_pipeline_succeeds.html)
-
-## Test and Deploy
-
-Use the built-in continuous integration in GitLab.
-
-- [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/index.html)
-- [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
-- [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
-- [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
-- [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)
-
-***
-
-# Editing this README
-
-When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thanks to [makeareadme.com](https://www.makeareadme.com/) for this template.
-
-## Suggestions for a good README
-
-Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.
-
-## Name
-Choose a self-explaining name for your project.
-
-## Description
-Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.
-
-## Badges
-On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.
-
-## Visuals
-Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.
-
-## Installation
-Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.
-
-## Usage
-Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.
-
-## Support
-Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.
-
-## Roadmap
-If you have ideas for releases in the future, it is a good idea to list them in the README.
-
-## Contributing
-State if you are open to contributions and what your requirements are for accepting them.
-
-For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.
-
-You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.
-
-## Authors and acknowledgment
-Show your appreciation to those who have contributed to the project.
-
-## License
-For open source projects, say how it is licensed.
-
-## Project status
-If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.
+# Start Documentation serve :
+ mkdocs serve -f config/fr/mkdocs.yml
+
\ No newline at end of file
diff --git a/config/en/mkdocs.yml b/config/en/mkdocs.yml
new file mode 100644
index 0000000000000000000000000000000000000000..eccdf11b000eea6dab2c82d477b08151e6524d82
--- /dev/null
+++ b/config/en/mkdocs.yml
@@ -0,0 +1,25 @@
+site_name: "Asynchronous Contact Tracing"
+docs_dir: "../../docs/en"
+site_dir: "../../generated/en"
+
+theme:
+ name: material
+ custom_dir: "../../overrides/"
+ language: en
+
+extra:
+ alternate:
+ - name: English
+ link: /en/
+ lang: en
+
+ - name: Français
+ link: /fr/
+ lang: fr
+
+plugins:
+ - search:
+ lang: en
+
+nav:
+ - Bienvenue: index.md
diff --git a/config/fr/mkdocs.yml b/config/fr/mkdocs.yml
new file mode 100644
index 0000000000000000000000000000000000000000..d5796cbc01ad8647410c11c19c3f78e06a3637e4
--- /dev/null
+++ b/config/fr/mkdocs.yml
@@ -0,0 +1,47 @@
+site_name: "Asynchronous Contact Tracing"
+docs_dir: "../../docs/fr"
+site_dir: "../../generated/fr"
+
+theme:
+ name: material
+ custom_dir: "../../overrides/"
+ language: fr
+
+extra:
+ alternate:
+ - name: English
+ link: /en/
+ lang: en
+
+ - name: Français
+ link: /fr/
+ lang: fr
+
+plugins:
+ - search:
+ lang: fr
+
+nav:
+ - Projet:
+ - Introduction: index.md
+ - Standardisation: project/standardization.md
+ - Technologies: project/technologies.md
+ - Crédits: project/credits.md
+ - Installation:
+ - Environnement: installation/environment.md
+ - National Control Service: explanations/national-control-service/ncs-installation.md
+ - Local Service: explanations/local-service/ls-installation.md
+ - Application utilisateur: explanations/display-application/da-installation.md
+ - Librairies: installation/act-library.md
+ - Documentation: installation/documentation.md
+ - Fonctionnement:
+ - Introduction: explanations/functioning.md
+ - Erreurs et Solutions: errors/getting-started.md
+markdown_extensions:
+ - pymdownx.superfences:
+ custom_fences:
+ - name: mermaid
+ class: mermaid
+ format: !!python/name:pymdownx.superfences.fence_code_format
+ - pymdownx.tabbed:
+ alternate_style: true
diff --git a/docs/en/index.md b/docs/en/index.md
new file mode 100644
index 0000000000000000000000000000000000000000..f533653cc09f3c6076e2b0fa75ea0d8805bd912b
--- /dev/null
+++ b/docs/en/index.md
@@ -0,0 +1 @@
+# ACT
diff --git a/docs/fr/errors/getting-started.md b/docs/fr/errors/getting-started.md
new file mode 100644
index 0000000000000000000000000000000000000000..e129801314685dcc71e055b878170adb343303c7
--- /dev/null
+++ b/docs/fr/errors/getting-started.md
@@ -0,0 +1,85 @@
+# Résolutions d'erreur au démarrage
+
+## Problème de connexion à la base de données
+```bash
+Error connecting to the database : No servers found yet, Timeout: 2.0s, Topology Description: <TopologyDescription id: 66d182b1fb658ad1223aae5a, topology_type: Single, servers: [<ServerDescription ('act_database', 27017) server_type: Unknown, rtt: None>]>
+```
+Pour résoudre ce problème, vous devez vérifier que la base de données est bien démarrée. Pour cela, vous pouvez utiliser la commande suivante :
+```bash
+docker-compose --profile dev up
+```
+Si la base de données est déjà démarrée, vous pouvez vérifier que l'url de connexion dans le fichier `./Server/src/config/config.py` est correcte.
+Pour cela, vous pouvez vérifier que le profile est bien configuré en mode développement :
+```python
+config = Config(Profile.DEV)
+```
+
+## Problème de démarrage d'ACME CSE
+Si vous rencontrez des problèmes lors du démarrage d'ACME CSE, vous pouvez vérifier que le fichier de configuration est correctement formé.
+
+```ini
+[basic.config]
+cseType=IN
+cseID=id-in
+cseName=cse-in
+adminID=CAdmin
+networkInterface=0.0.0.0
+cseHost=${hostIPAddress}/acme
+httpPort=8080
+databaseType=memory
+logLevel=debug
+consoleTheme=dark
+
+[cse.registration]
+allowedCSROriginators=id-in,id-mn,id-asn
+
+[textui]
+startWithTUI=false
+
+[cse]
+enableSubscriptionVerificationRequests=false
+
+[cse.operation.requests]
+enable=true
+
+[http]
+enableUpperTesterEndpoint=true
+enableStructureEndpoint=true
+address=http://localhost:8080/acme
+root=/acme
+```
+
+## Problème de connexion à ACME
+
+```bash
+HTTPConnectionPool(host='HOST', port=PORT): Max retries exceeded with url: /acme/cse-in (Caused by NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7f4ba5d01c90>: Failed to establish a new connection: [Errno 111] Connection refused'))
+```
+Si vous rencontrez ce problème, vous devez vérifier que le service ACME est bien démarré. Pour cela, vous pouvez utiliser la commande suivante :
+```bash
+cd acces/au/dossier/ACME
+python -m acme
+```
+Si l'erreur persiste, vérifier que l'url d'accès est correctement formée. Pour cela, allez vérifier dans le fichier `config.ini` au champs
+```ini
+[http]
+address=http://localhost:8080/acme
+```
+Et tentez de vous connecter à l'url suivante : `http://localhost:8080/acme/cse-in`
+
+## Erreur requête sur ACME
+Si vous rencontrez l'erreur ci-dessous c'est que la requête envoyée à ACME est incorrecte.
+```json
+{
+ "m2m:dbg": "invalid arguments/attributes: request identifier parameter is mandatory in request"
+}
+```
+En effet, OneM2M requiert différents champs obligatoires pour effectuer une requête. Pour résoudre ce problème, veuillez ajouter les entêtes suivantes :
+```json
+{
+ "X-M2M-RVI": "3",
+ "X-M2M-Origin": "CAdmin",
+ "X-M2M-RI": "153",
+}
+```
+Pour comprendre la signification de ces champs, vous pouvez consulter la documentation d'ACME [ici](https://recipes.onem2m.org/introduction/What-are-oneM2M-Requests/#requests) :
+
diff --git a/docs/fr/explanations/TS103757.diagramme.png b/docs/fr/explanations/TS103757.diagramme.png
new file mode 100644
index 0000000000000000000000000000000000000000..300bd863f355ed15a302d8715f989851231e6aad
Binary files /dev/null and b/docs/fr/explanations/TS103757.diagramme.png differ
diff --git a/docs/fr/explanations/display-application/da-installation.md b/docs/fr/explanations/display-application/da-installation.md
new file mode 100644
index 0000000000000000000000000000000000000000..db5c66a2e3ff7ce32d7b8f39411dfcc7d6b50bd1
--- /dev/null
+++ b/docs/fr/explanations/display-application/da-installation.md
@@ -0,0 +1,32 @@
+# Applications utilisateurs
+
+Vous avez deux applications utilisateurs.
+
+## Site internet
+
+### Installation
+Pour installer le site web il suffit de cloner le dépôt gitlab privé du projet act.
+
+```bash
+git clone git@gitlab.inria.fr:act/website.git
+cd website
+```
+Vous pouvez ensuite soit démarrer un live server et vous rendre sur l'url d'ouverture, soit utiliser la CICD pour automatiquement déployer le site web et vous rendre sur [le site](http://act.inria.fr)
+
+
+## Application mobile
+
+### Installation
+Pour installer l'application mobile, vous devez cloner le dépôt gitlab privé du projet act.
+
+```bash
+git clone git@gitlab.inria.fr:act/mobile-app.git
+cd mobile-app
+```
+Vous pouvez ensuite suivre les étapes suivantes pour installer l'application mobile.
+1. Ouvrir le dossier mobile-app dans Android Studio.
+2. Suivre les instructions de votre IDE si celui-ci demande une phase de configuration.
+3. Dans la barre d'outils en haut de la fenêtre, cliquer sur Build > Build Bundle(s) / APK(s) > Build APK(s).
+4. Attendre un peu (le temps de chargement est visible en bas à droite de la fenêtre).
+5. Cliquer sur locate à la fin du build pour localiser le fichier APK dans vos dossiers et le copier sur votre appareil mobile (par câble, par exemple).
+6. Installer le fichier APK.
diff --git a/docs/fr/explanations/functioning.md b/docs/fr/explanations/functioning.md
new file mode 100644
index 0000000000000000000000000000000000000000..8c8be2f77a4fa7c5ef11792d33ee013fbb366e16
--- /dev/null
+++ b/docs/fr/explanations/functioning.md
@@ -0,0 +1,37 @@
+# Fonctionnement
+
+## Architecture
+Le projet ACT est divisé en différents composants pour respecter le diagramme décrit dans le document de [spécification technique](https://inria.hal.science/hal-02989793/document)
+
+### Diagramme
+
+### Composants
+
+Dans ce diagramme, on peut voir les différents composants de l'application.
+#### National Control Service
+Le National Control Service est le composant responsable de la gestion des données de l'application. Il est composé d'une base de donnée MongoDB, et d'un serveur Flask.
+Par soucis de simplicité, c'est également celui qui sera hôte d'ACME et du Broker MQTT.
+
+[Voir plus](./national-control-service/explanations.md)
+#### Local Service
+L'application est faite pour pouvoir créer plusieurs local services. Un local service peut être créé par différentes entités (une entreprise, un hopital, ou même un particulier).
+Il est divisable en deux parties :
+- La partie Detection service qui est hosté sur un local service
+- La partie local Service qui est composée d'un serveur Flask.
+
+Les Local services servent de passerelle entre le detection service et le National Control Service. Ils reçoivent les données du detection service et les envoies au National Control Service.
+
+#### Detection Service
+Le Detection Service peut-être résumé dans ce proof of concept en un capteur. Dans l'état actuel (version 1.0), il est simulé par un script python qui envoie des données aléatoires au Local Service.
+
+#### Peripheral Service
+Le peripheral service est comparable à un reseau wifi. Il est lié a un detection service (qui indique s'il y a des traces du covid proche du reseau). Il peut également être détecté par des téléphones.
+
+#### Les Applications
+Il y a deux applications mobile et web. Elles permettent aux utilisateurs communs de voir les zones contaminées par le covid. L'application mobile est composée d'une fonctionnalité supplémentaire. Elle garde en mémoire la liste des réseaux wifi a proximité et une fois qu'elle fait une requête au national control service, elle compare les réseaux wifi a proximité avec ceux enregistrés dans la base de donnée. Si la personne était a proximité d'un réseau wifi contaminé, elle est notifiée.
+
+#### Extensions
+Un des futurs objectifs est de permettre au national control service d'échanger des données avec d'autres national control services. Cela permettrait d'identifier les zones de contaminations dans les pays voisins et cela pourrait être implémenté grâce à un système de routage automatique.
+
+Le routage inter-cse est une fonctionnalité du standard oneM2M qui n'est pas encore disponible dans la version 3 et est prévue pour la version 5.
+
diff --git a/docs/fr/explanations/local-service/ls-installation.md b/docs/fr/explanations/local-service/ls-installation.md
new file mode 100644
index 0000000000000000000000000000000000000000..005fbfaa91267ed101ee7182337e3d6bc749e2c5
--- /dev/null
+++ b/docs/fr/explanations/local-service/ls-installation.md
@@ -0,0 +1,45 @@
+# Installation du Local Service
+
+## Installation
+
+Pour installer le service local, vous devez cloner le dépôt gitlab privé du projet act.
+
+```bash
+git clone git@gitlab.inria.fr:act/local-service.git
+cd local-service
+```
+Une fois le projet cloné, vous pouvez créer un environnement virtuel et installer les dépendances du projet.
+
+=== "Linux"
+ ```bash
+ python -m venv myenv
+ source myenv/bin/activate
+ ```
+=== "Windows"
+ ```bash
+ python -m venv myenv
+ myenv/Scripts/activate
+ ```
+=== "macOS"
+ ```bash
+ python -m venv myenv
+ source myenv/bin/activate
+ ```
+Une fois l'environnement virtuel activé, vous pouvez installer les dépendances du projet.
+
+```bash
+pip install -r requirements.txt
+```
+## Démarrage
+
+Avant de démarrer le Local Service veuillez démarrer le National Control Service.
+
+Pour démarrer le service local, vous pouvez utiliser la commande suivante :
+
+```bash
+python -m Services
+```
+Lors du premier démarrage, un fichier de configuration .ini sera créé grâce au CLI. Vous devrez renseigner les informations nécessaires pour la connexion au National Control Service.
+Si vous souhaitez utiliser l'environnement de développement local de base, vous pouvez appuyer sur la touche `Entrée` pour valider les valeurs par défaut.
+
+Vous pouvez ensuite lancer le panel de contrôle du service en vous rendant sur l'adresse [http://localhost:8090](http://localhost:8090).
diff --git a/docs/fr/explanations/national-control-service/explanations.md b/docs/fr/explanations/national-control-service/explanations.md
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/docs/fr/explanations/national-control-service/ncs-installation.md b/docs/fr/explanations/national-control-service/ncs-installation.md
new file mode 100644
index 0000000000000000000000000000000000000000..3adc0ebbeff2bc8ab932677a73b5d188f6d2b2c0
--- /dev/null
+++ b/docs/fr/explanations/national-control-service/ncs-installation.md
@@ -0,0 +1,186 @@
+# Installation du National Control Service
+## Préambule
+Pour simplifier le déploiement de l'application, nous utilisons du profilage : DEV est le profile pour utiliser les URL locales et PROD les URL de production (notamment celles du docker network).
+
+## Clonage du projet
+Pour débuter, vous pouvez clôner le projet :
+```bash
+git clone git@gitlab.inria.fr:act/national-control-service.git
+cd national-control-service
+```
+## Activation de l'environnement virtuel
+
+Vous pouvez activer l'environnement virtuel en utilisant la commande suivante :
+
+=== "Linux"
+ ```bash
+ python -m venv myenv
+ source myenv/bin/activate
+ ```
+=== "Windows"
+ ```bash
+ python -m venv myenv
+ myenv/Scripts/activate
+ ```
+=== "macOS"
+ ```bash
+ python -m venv myenv
+ source myenv/bin/activate
+ ```
+
+Si vous appelez votre environnement virtuel différemment, vous devez ajouter son nom au fichier `.gitignore`.
+
+## Installation des dépendances
+Une fois l'environnement virtuel activé, vous pouvez installer les dépendances du projet.
+
+```bash
+pip install -r requirements.txt
+```
+
+## Base de données et Broker MQTT
+Il existe différentes manière de démarrer la base de données MongoDB. Dans un objectif de simplification de l'application, il est recommandé d'utiliser Docker.
+
+Si vous souhaitez utiliser une base de données local, il faudra changer l'url de connexion dans le fichier `./Server/src/config/config.py`.
+
+Vous pouvez configurer le broker MQTT (mosquitto) en créant l'aborescence suivante :
+```bash
+cd ./national-control-service
+mkdir -p ./mosquitto/config ./mosquitto/data ./mosquitto/log
+```
+Puis, vous pouvez créer un fichier `mosquitto.conf` dans le dossier `./mosquitto/config` avec le contenu suivant :
+```conf
+persistence true
+persistence_location /mosquitto/data/
+log_dest file /mosquitto/log/mosquitto.log
+listener 1883
+allow_anonymous true
+```
+
+Vous pouvez ensuite démarrer les dépendances avec la commande suivante :
+
+```bash
+docker-compose --profile dev up
+```
+Ceci permet de démarrer tous les composants du docker-compose lié au profile "dev".
+
+## ACME CSE
+
+Suite à l'installation d'ACME, vous pouvez créer un environnement virtuel:
+=== "Linux"
+ ```bash
+ python -m venv myenv
+ source myenv/bin/activate
+ ```
+=== "Windows"
+ ```bash
+ python -m venv myenv
+ myenv/Scripts/activate
+ ```
+=== "macOS"
+ ```bash
+ python -m venv myenv
+ source myenv/bin/activate
+ ```
+Puis, installer les dépendances avec la commande suivante :
+```bash
+pip install -r requirements.txt
+```
+
+Au premier démarrage d'ACME vous avez une configuration à faire. Pour cela, vous pouvez suivre les options par défaut. Une fois la configuration terminée, vous pouvez vous rendre dans le fichier `acme.ini` et copier le fichier de configuration suivant :
+
+```ini
+[basic.config]
+cseType=IN
+cseID=id-in
+cseName=cse-in
+adminID=CAdmin
+networkInterface=0.0.0.0
+cseHost=${hostIPAddress}/acme
+httpPort=8080
+databaseType=memory
+logLevel=debug
+consoleTheme=dark
+
+[cse.registration]
+allowedCSROriginators=id-in,id-mn,id-asn
+
+[textui]
+startWithTUI=false
+
+[cse]
+enableSubscriptionVerificationRequests=false
+
+[cse.operation.requests]
+enable=true
+
+[http]
+enableUpperTesterEndpoint=true
+enableStructureEndpoint=true
+address=http://localhost:8080/acme
+root=/acme
+```
+Vous pouvez ensuite démarrer ACME avec la commande suivante :
+```bash
+python -m acme
+```
+Vous pourrai y accéder via l'adresse : `http://localhost:8080/acme`
+
+## National Control Service
+Une fois les pré-requis installés, vous pouvez débuter l'installation du projet
+
+Il est recommandé d'utiliser un environnement virtuel pour isoler les dépendances du projet. Pour cela, vous pouvez utiliser `venv` qui est inclus dans Python.
+
+=== "Linux"
+ ```bash
+ python -m venv myenv
+ source myenv/bin/activate
+ ```
+=== "Windows"
+ ```bash
+ python -m venv myenv
+ myenv/Scripts/activate
+ ```
+=== "macOS"
+ ```bash
+ python -m venv myenv
+ source myenv/bin/activate
+ ```
+Une fois l'environnement virtuel activé, vous pouvez installer les dépendances du projet.
+
+```bash
+pip install -r requirements.txt
+```
+
+Toutes les dépendences étant satisfaites, on peut ensuite démarrer le National Control Service avec la commande suivante :
+
+```bash
+python -m Server
+```
+L'API du serveur est accessible via l'adresse : `http://localhost:5000`
+Vous pouvez changer la configuration du serveur en accédant au fichier `./Server/src/config/config.py`.
+
+Une fois tous les composants démarrés vous pouvez vérifié que tout fonctionne correctement en tapant `#` dans la console ACME et vous pourrait voir l'arborecence suivante :
+```
++ cse-in
+| +--AccessControlPolicy
+| +--acpCreateACPs
+| +--ApplicationEntity
+| +--CAdmin
+| // Au dessus toutes les configurations par défaut
+|
+| // En dessous toutes les configurations que l'on vient d'ajouter
+| +--ControlService
+| | ...
+|
+| +--DisplayApplication
+| | ...
+```
+
+## Explications
+
+Le National Control Service utilise une base de donnée MongoDB qui est hébergée dans un conteneur Docker.
+ACME est le middleware utilisé pour faire communiquer les différents composants de l'application. Il ne peut pas être hébergé sur docker pendant la phase de production car il doit être possible de faire des requêtes entrantes et sortantes via localhost.
+
+Par exemple un composant créer une donnée qui doit notifier localhost, or si ACME est hébergé sur Docker, il notifiera l'adresse IP du conteneur Docker et non localhost.
+
+
diff --git a/docs/fr/index.md b/docs/fr/index.md
new file mode 100644
index 0000000000000000000000000000000000000000..61686f6b32a4023f61aa88d85d859e598ec6d465
--- /dev/null
+++ b/docs/fr/index.md
@@ -0,0 +1,13 @@
+# [ ACT ]: Asynchronous Contact Tracing
+L'application Asynchronous Contact Tracing ( ACT ) est un proof of concept d'une implémentation du standard ACT de l'ETSI.
+
+## Fonctionnement
+
+### Test groupés de Dorfman
+L'idée principale du système ACT est d'utiliser la méthode de tests groupés de Dorfman. Au lieu de tester chaque individu séparément, un ensemble d'échantillons est regroupé et testé ensemble. Ainsi, si le résultat est positif, des tests individuels sont réalisés pour identifier précisément les personnes contaminées. En revanche, si le résultat est négatif, plusieurs personnes peuvent être confirmées comme exemptes du virus avec un seul test. Ce processus accélère les tests, réduit les coûts et simplifie la logistique.
+
+### En pratique
+Tester des lieux plutôt que des individus serait équivalent à la méthode précédente. Par exemple, pour détecter un agent pathogène transmis par l'air ou les gouttelettes d'eau, on pourrait tester les filtres de climatisation dans une salle de réunion, ou l'eau sale recueillie après le nettoyage dans un supermarché. L'idée est donc d'utiliser des dispositifs autonomes et faciles à utiliser, de sorte qu'un agent d'entretien puisse prélever un échantillon et l'insérer dans l'appareil, qui se chargera ensuite de tester et de transmettre les résultats à une base de données nationale. La recherche de tels dispositifs est actuellement en cours par une entreprise de microbiologie en partenariat avec Inria dans le cadre du projet PANDESYS.
+
+De plus, ces dispositifs peuvent être configurés pour être liés à une box Internet proche de la source de l'échantillon qu'ils traitent. De cette manière, la zone de détection serait comparable à celle du réseau wifi émis par le point d'accès.
+
diff --git a/docs/fr/installation/act-library.md b/docs/fr/installation/act-library.md
new file mode 100644
index 0000000000000000000000000000000000000000..5d9f02d938ea20d817eea4ff545412e11d1ef34a
--- /dev/null
+++ b/docs/fr/installation/act-library.md
@@ -0,0 +1,16 @@
+# ACT Librairie
+
+La librairie est un composant de l'application contenant tout le code générique entre les composants tel que l'enregistrement sur l'application, l'envoie de message, ainsi que leur contenu.
+
+## Installation
+L'installation de la librairie n'est pas nécessaire car elle est incluse dans le projet. Il est possible de la télécharger via le Gitlab Package Registry.
+
+Pour installer et modifier la librairie, vous devez cloner le dépôt gitlab privé du projet act.
+
+```bash
+git clone git@gitlab.inria.fr:act/library.git
+cd library
+```
+
+Vous pouvez ensuite modifier le code de la librairie. Si vous souhaitez tester vos modifications, vous pouvez créer un environnement virtuel et installer les dépendances du projet.
+
diff --git a/docs/fr/installation/documentation.md b/docs/fr/installation/documentation.md
new file mode 100644
index 0000000000000000000000000000000000000000..a6bbc4275b530750e5f10cdc3b9c16e1344d5ad4
--- /dev/null
+++ b/docs/fr/installation/documentation.md
@@ -0,0 +1,23 @@
+# Documentation
+
+Pour installer la documentation, vous devez cloner le dépôt gitlab privé du projet act.
+
+```bash
+git clone git@gitlab.inria.fr:act/documentation.git
+cd documentation
+```
+
+Installer mkdocs via pip
+
+```bash
+pip install mkdocs
+```
+
+Vous pouvez ensuite utiliser les différentes commandes de MkDocs pour visualiser la documentation.
+
+```bash
+mkdocs serve -f config/fr/mkdocs.yml
+mkdocs serve -f config/en/mkdocs.yml
+mkdocs build -f config/fr/mkdocs.yml
+mkdocs build -f config/en/mkdocs.yml
+```
\ No newline at end of file
diff --git a/docs/fr/installation/environment.md b/docs/fr/installation/environment.md
new file mode 100644
index 0000000000000000000000000000000000000000..b7088a40ddde6d58596a7061c567a4401ee63b8e
--- /dev/null
+++ b/docs/fr/installation/environment.md
@@ -0,0 +1,66 @@
+# Environnement de développement
+Voici la démarche pour installer le projet en local.
+## Prérequis
+
+Pour pouvoir travailler sur le projet, vous devez disposer d'un environnement de développement adapté. Voici les prérequis nécessaires pour pouvoir travailler sur le projet.
+
+- Git pour cloner le projet. Vous pouvez le télécharger [ici](https://git-scm.com/downloads).
+- Python 3.11 ou supérieur. Vous pouvez le télécharger [ici](https://www.python.org/downloads/).
+- Docker Desktop. Vous pouvez le télécharger [ici](https://www.docker.com/products/docker-desktop).
+- ACME CSE. Vous pouvez le télécharger: il est fortement conseillé d'utiliser le dépôt github pour installer ACME (installation manuelle) pour avoir une plus grande personnalisation. [ici](https://acmecse.net).
+
+## Connexion au Gitlab privé
+
+Pour vous connecter au projet, vous devez demander à M. Luigi Liquori de vous inviter au projet act. Une fois que cela sera fait, vous pourrez utiliser une clé SSH pour vous connecter au dépôt Gitlab privé.
+
+=== "Linux"
+ ```bash
+ ssh-keygen
+ cat ~/.ssh/id_rsa.pub
+ ```
+=== "Windows"
+ ```bash
+ ssh-keygen
+ type %USERPROFILE%\.ssh\id_rsa.pub
+ ```
+=== "macOS"
+ ```bash
+ ssh-keygen
+ cat ~/.ssh/id_rsa.pub
+ ```
+Puis copiez la clé SSH générée et ajoutez-la à votre profil Gitlab. ( Edit Profile > SSH Keys > Add SSH Key )
+
+## Conseils
+
+Il est fortement conseillé d'utiliser un environnement virtuel pour isoler les dépendances du projet. Pour cela, vous pouvez utiliser `venv` qui est inclus dans Python.
+
+Note : Si vous souhaitez utiliser un nom spécifique pour votre environnement virtuel, vous devez l'ajouter au fichier `.gitignore`.
+
+=== "Linux"
+ ```bash
+ python -m venv myenv
+ source myenv/bin/activate
+ ```
+=== "Windows"
+ ```bash
+ python -m venv myenv
+ myenv/Scripts/activate
+ ```
+=== "macOS"
+ ```bash
+ python -m venv myenv
+ source myenv/bin/activate
+ ```
+
+Une fois l'environement virtuel activé, vous pouvez installer les dépendances du projet.
+
+```bash
+pip install -r requirements.txt
+```
+
+Une fois les pré-requis installés, vous pouvez débuter le développement du projet.
+Pour débuter, vous pouvez démarrer les différents composants de l'application :
+
+- [National Control Service](../explanations/national-control-service/ncs-installation.md)
+- [Local Service](../explanations/local-service/ls-installation.md)
+- [ACT librairie](./act-library.md)
\ No newline at end of file
diff --git a/docs/fr/project/credits.md b/docs/fr/project/credits.md
new file mode 100644
index 0000000000000000000000000000000000000000..72653c810213a5c69b255ea1a5059935468ef19d
--- /dev/null
+++ b/docs/fr/project/credits.md
@@ -0,0 +1,13 @@
+# Contributeurs
+
+## Management
+- **Luigi Liquori** Directeur de recherche Centre INRIA Université Côte d'Azur
+## Conseils et supervision
+- **Andreas Kraft** Ingénieur Senior de Detusche Telekom et développeur de la librairie ACME
+- **Pascal Tempier** Ingénieur de production des infrastructures de recherche du Centre INRIA Université Côte d'Azur
+
+## Développement
+- **Thomas Gorisse** 07/2024 - 09/2024
+- **Antoine Fadda Rodriguez** 05/2024 - 07/2023
+- **Antoine Maïstre-Rice** 05/2024 - 07/2023
+- **Alessio Di Dio Stage** 05/2024 - 07/2023 [TODO]
diff --git a/docs/fr/project/standardization.md b/docs/fr/project/standardization.md
new file mode 100644
index 0000000000000000000000000000000000000000..563a902852175bc50b018b763ddfb90ed3d24bab
--- /dev/null
+++ b/docs/fr/project/standardization.md
@@ -0,0 +1,13 @@
+# Standardisation
+## ACT
+L'implémentation d'ACT n'est qu'une preuve de concept du standard décrit par l'ETSI. Un document de spécification technique a été rédigé par Luigi Liquori, Enrico Scarrone, Suno Wood, Lanting Cees, Francisco Dasilva, Markus Maass, Flynn Bob, Thomas Kessler, Holoyad Taras et Massimo Vanetti.
+
+On peut retrouver la description technique dans le document [TS 103 757](https://inria.hal.science/hal-02989793/document). Il décrit les composants principaux de l'application, ainsi que les échanges entre chacun d'entre eux.
+
+## OneM2M
+
+Pour assurer la communication entre les différents composants de l'application, Luigi Liquori a décidé d'utiliser le standard OneM2M. Il est utilisé dans des projets de l'[Internet of Things](https://fr.wikipedia.org/wiki/Internet_des_objets).
+
+OneM2M est un partenariat entre huit des principaux organismes de normalisation mondiaux. ARIB (Japon), ATIS (USA), CCSA (Chine), ETSI (Europe), TIA (USA), TSDSI (Inde), TTA (Corée) et TTC (Japon) travaillent ensemble depuis 2012 pour créer des spécifications techniques assurant une architecture système efficace et des communications pour les systèmes IoT (Internet des Objets) et Machine-to-Machine (M2M). Le nom du partenariat a été adopté comme nom de la norme créée. La première version, composée de plusieurs documents de spécifications techniques rédigés en anglais, a été publiée en février 2015, posant les bases. Le projet ACT est basé sur la troisième version de la norme, datée de décembre 2018. Cette norme est déjà utilisée dans le réseau IoT du gouvernement indien et dans celui de la ville de Bordeaux.
+
+Selon cette norme, notre réseau IoT doit être organisé en structure arborescente, avec une racine appelée CSE (Common Service Entity). Cette racine agit comme une API REST à laquelle tous les dispositifs du système doivent s'enregistrer pour pouvoir communiquer entre eux. La communication dans cet arbre se fait selon le modèle de publication/souscription (pub/sub) et avec l'aide de différents types de ressources pouvant être présentes dans l'arbre : Application Entity (AE), Container (CTN), Content Instance (CIN) et Subscribe (SUB) sont les plus courants.
\ No newline at end of file
diff --git a/docs/fr/project/technologies.md b/docs/fr/project/technologies.md
new file mode 100644
index 0000000000000000000000000000000000000000..257929dda905814c8ac717ac425232325992515d
--- /dev/null
+++ b/docs/fr/project/technologies.md
@@ -0,0 +1,16 @@
+# Technologies utilisées
+
+L'application Asynchronous Contact Tracing utilise divers langages de programmation et technologies.
+
+## Langages de programmation
+
+- **Python** [v3.11 ou +]: Langage de programmation utilisé pour le développement de l'application métier.
+- **HTML/CSS/JS** : Langages de programmation utilisés pour le développement de l'interface web.
+- **Kotlin** : Langage de programmation utilisé pour le développement de l'application mobile.
+- **MongoDB** : Système de gestion de base de données.
+## Technologies
+
+- **ACME** : Librairie Python pour la communication OneM2M. [Andreas Kraft](./credits.md#conseils-et-supervision)
+- **Flask** : Framework Python pour le développement d'applications web.
+- **TurfJs** : Librairie JavaScript lié à la cartographie.
+- **WifiAnalyzer** : Application Android pour l'analyse des réseaux wifi.
\ No newline at end of file
diff --git a/overrides/assets/TS103757.diagramme.png b/overrides/assets/TS103757.diagramme.png
new file mode 100644
index 0000000000000000000000000000000000000000..300bd863f355ed15a302d8715f989851231e6aad
Binary files /dev/null and b/overrides/assets/TS103757.diagramme.png differ