add base documentation

Documentation/.gitignore

+# Created by https://www.toptal.com/developers/gitignore/api/venv
+# Edit at https://www.toptal.com/developers/gitignore?templates=venv
+
+### venv ###
+# Virtualenv
+# http://iamzed.com/2009/05/07/a-primer-on-virtualenv/
+.Python
+[Bb]in
+[Ii]nclude
+[Ll]ib
+[Ll]ib64
+[Ll]ocal
+[Ss]cripts
+pyvenv.cfg
+.venv
+pip-selfcheck.json
+
+# End of https://www.toptal.com/developers/gitignore/api/venv
+
+/site

Documentation/README.md

+# projet_isc_l431 - documentation
+
+Ce repo git contient la documentation pour le projet réalisé dans le cadre du cours d'ateliers logiciels.
+
+Ce repo contient également un fichier de configuration [MkDocs](https://www.mkdocs.org) permettant de facilement visualiser la documentation (en local).
+
+
+## Installation du repo
+
+Cloner le projet :
+
+```
+git clone ssh://git@ssh.hesge.ch:10572/in-code-we-trust/documentation.git
+```
+
+Créer et activer l'environnement virtuel :
+
+```
+python -m venv .venv
+source .venv/bin/activate
+```
+
+Installer les dépendances :
+
+```
+python -m pip install -r requirements.txt
+```
+
+
+## Structure de la documentation
+
+Les fichiers de documentation utilisent le format markdown (`.md`) et se trouvent dans le dossier `docs`.
+
+Le dossier `docs/img` contient les différentes images utilisées dans la documentation.
+
+Le fichier `mkdocs.yml` est le fichier de configuration MkDocs.
+
+> Tous les autres fichiers pouvant servir à la documentation mais qui ne sont ni pas des images ou `.md` doivent se 
+trouver dans un dossier et/ou à la racine du repo.
+
+
+## MkDocs
+
+L'utilisation de MkDocs permet de consulter facilement la documentation du projet.
+
+Son utilisation n'est pas indispensable si consulter les fichiers `.md` est suffisant pour vous, néanmoins son 
+installation est vivement recommandée afin de générer un site statique permettant de parcourir et consulter simplement 
+la documentation.
+
+
+### Utilisation
+
+*Pensez à bien activer l'environnement virtuel au préalable.*
+
+À la racine du projet, la commande suivante permet de visualiser la documentation :
+
+```
+mkdocs serve
+```
+
+Ouvrir un navigateur à l'adresse `http://127.0.0.1:8000/` affiche le site généré, permettant de consulter la 
+documentation.
+
+Si nécessaire, il est possible de changer le port utilisé à l'aide du paramètre `-a` :
+
+```
+mkdocs serve -a "127.0.0.1:9876"
+```
+
+L'exemple ci-dessus rend le site accessible en `http://127.0.0.1:9876`.
+
+### Générer le site
+
+Il est possible de générer le site avec la commande suivante :
+
+```
+mkdocs build
+```
+
+Cette commande produit un dossier `site` contenant la documentation sous forme d'un site web. Il est ensuite possible 
+d'héberger ce dossier afin de la rendre accessible à tout le monde.
+
+
+## Écrire la documentation
+
+### Enrichir la documentation
+
+[Material for MkDocs](https://squidfunk.github.io/mkdocs-material/reference/) met à disposition de nombreuses extensions
+offrant de nombreuses fonctionnalités pour enrichir la documentation. N'hésitez pas à y jetter un oeil afin de voir ce
+qui est disponible.
+
+
+### Ajouter une page
+
+Si vous souhaitez ajouter une page, pour par exemple expliquer une nouvelle fonctionnalité, il suffit simplement de 
+créer un fichier `<my_file>.md` dans le dossier correspondant (ex: `backend/<my_file>.md` pour une fonctionnalité du 
+serveur).
+
+Il faut ensuite ajouter le fichier dans la navigation définie dans la configuration de 
+[mkdocs](https://gitedu.hesge.ch/in-code-we-trust/documentation/-/blob/main/mkdocs.yml).
+
+
+L'ajout se fait de la manière suivante :
+
+```yml
+nav:
+    # ...
+    - Backend:
+      - Introduction:
+        - backend/index.md
+      - Gestion des données:
+        - Modèles: 'backend/models.md'
+        - Migrations: 'backend/migrations.md'
+        - Sérialisation: 'backend/serialization.md'
+        - <Nom de section>: 'backend/<my_file>.md' # Le chemin vers le nouveau fichier
+      - Fonctionnement:
+        - REST framework: 'backend/rest_framework.md'
+    # ...
+```
+
+*Remplacer respectivement `<Nom de section>` et `<my_file>` avec un nom de section et le nom du fichier de votre page.*
+
+
+## Déploiement de la documentation avec Docker
+
+Actuellement, le déploiement de la documentation sur le serveur distant s'effectue à l'aide de docker compose.
+
+
+### Prérequis
+
+Il est impératif que ce serveur puisse accéder au projet git en SSH.
+
+*Les clefs SSH expireront le 8 juillet 2023.*
+
+
+Le serveur doit pouvoir créer une image docker et lancer un container à partir de cette image.
+
+
+### Marche à suivre
+
+Se connecter au serveur [wetty](https://silentpc.ciuj-kune.org/wetty).
+
+- Pour le premier déploiement, exécuter les commandes suivantes :
+
+```
+git clone ssh://git@ssh.hesge.ch:10572/in-code-we-trust/documentation.git
+cd documentation
+python -m pip install -r requirements.txt
+mkdocs build
+```
+
+Note: Le fichier `check-container.bash` permet de vérifier qu'un conteneur de notre image est existant. Dans le cas 
+contraire il va exécuter le fichier `setup-prod.bash` avec le paramètre `-f`, forçant le déploiement de notre 
+*container*.
+
+Se rendre ensuite sur la page des Stacks du [portainer](https://silentpc.ciuj-kune.org/portainer/#!/2/docker/stacks)
+
+1. Cliquer sur le bouton `+ Add stack`
+2. Donner un nom à la stack : `icwt`
+3. Sélectionner l'option `Upload`
+4. Cliquer sur le bouton `Select file` et sélectionner le fichier `docker-compose.yml`
+5. En bas de page, cliquer sur le bouton `Deploy the stack`
+
+La documentation est ensuite accessible [ici](http://silentpc.ciuj-kune.org:2100/).
+
+### Bind mount
+
+Le dossier `site/`, généré par la commande `mkdocs build` est monté sur le conteneur docker à l'aide du fichier 
+`docker-compose.yml`.
+
+En cas de modification de la documentation il suffit d'effectuer la commande `mkdocs build` pour que le containeur soit
+automatiquement mis à jour.
+
+
+### Automatisation
+
+Les scripts `setup-prod.bash` et `check-container.bash` permettent de mettre à jour automatiquement la documentation.
+
+Pour cela, il faut impérativement les rendre exécutables :
+
+```
+chmod +x setup-prod.bash
+chmod +x check-container.bash
+```
+
+Il est possible d'exécuter régulièrement le fichier `setup-prod.bash` à l'aide de crontab :
+
+```
+crontab -e
+0 3 * * * ~/documentation/setup-prod.bash
+```
+
+*Le fichier sera exécuté automatiquement tous les jours à 3H du matin.*
+
+
+Actuellement, le crontab sur le serveur est définit ainsi :
+
+```
+PATH=$PATH:/home/incode/.local/bin:/usr/bin
+0 * * * * ~/documentation/setup-prod.bash >> ~/crontab_logs/doc_setup.log 2>&1
+7 * * * * ~/documentation/check-container.bash >> ~/crontab_logs/doc_check.log 2>&1
+15 * * * * ~/documentation/setup-prod.bash >> ~/crontab_logs/doc_setup.log 2>&1
+22 * * * * ~/documentation/check-container.bash >> ~/crontab_logs/doc_check.log 2>&1
+30 * * * * ~/documentation/setup-prod.bash >> ~/crontab_logs/doc_setup.log 2>&1
+37 * * * * ~/documentation/check-container.bash >> ~/crontab_logs/doc_check.log 2>&1
+45 * * * * ~/documentation/setup-prod.bash >> ~/crontab_logs/doc_setup.log 2>&1
+52 * * * * ~/documentation/check-container.bash >> ~/crontab_logs/doc_check.log 2>&1
+```
+
+- La ligne `PATH=$PATH:/home/incode/.local/bin` nous assure que la commande mkdocs soit trouvée afin d'être correctement
+exécutée.
+
+- Les `>> ~/crontab_logs/<name>.log` permettent de rediriger la sortie des commandes dans un fichier.
+
+- Les `2>&1` vont rediriger la sortie d'erreur (`stderr`) dans la sortie standard (`stdout`), ce qui permet de garder une
+trace des erreurs lors de l'exécution des commandes.

Documentation/docs/api/get_user_info.md

+# GET /api/v1/users/:username
\ No newline at end of file

Documentation/docs/api/index.md

+# Explication de l'API
\ No newline at end of file

Documentation/docs/api/user_connect.md

+# POST /api/v1/guests/users/:username
\ No newline at end of file

Documentation/docs/api/user_create.md

+# POST /api/v1/guests/user
\ No newline at end of file

Documentation/docs/frontend/angular.md

+# Angular
\ No newline at end of file

Documentation/docs/frontend/babylonjs.md

+# Babylon JS
+

Documentation/docs/frontend/firebase.md

+# Firebase
+
+
+## Envoi des données à Firebase
+Toutes les méthodes utiles pour envoyer et recevoir des données à Firebase sont dans le fichier *meshprocess/src/app/project.service.ts*. Les méthodes qu'on a dans ce fichier nous est utiles a chaque fois qu'on souhaite actualiser la base de données ou bien envoyer un fichier pour le bon fonctionnement de nos pages ionic.
+Sachant que nos images ou les informations à propos de chaque projet et process doivent être stocké pour un meilleur rendu. 
+
+## Représentation de chaque projet
+Notre base de données Firebase est représenté comme suit:
+![Database structure](./img/structure-database.png)
+
+On peut voir ici que la structure dans la base de données est la même que dans notre code. À chaque ajout de projet un id unique est créer dans la base données avec les attributs du projet. Dans notre exemple ci-dessus, ce sera le projet qui contiendra tous les process qui ne vont pas être associé à des projets en particulier. Ce "projet"(qui n'est pas vraiment un au final), ne va pas être afficher sur notre page car ce n'est pas un projet en soit.
+
+À chaque ajout de process dans un projet, il y aura également un id unique par process.
+
+## Stockage des données **obj** de notre process
+
+Les données **obj** vont être stockées dans l'attribut *dataObj* de chaque process. On aura tout le contenu du fichier *.obj* qui va être récupérer à partir de notre backend Django.
+
+## Stockage des images
+
+Dans notre application web, on va devoir stocké une image pour chaque projet et chaque process. Grâce à Firebase on peut les stockés et pouvoir les récupérer facilement avec des lien qui seront stockés dans les attributs des projets et process dans la base de données. 
+
+![Image Storage](./img/img-storage.png)
+
+Les images de chaque projet sont stockés dans le dossier *Images*. Et les images de tous les process de chaque projet sont stockés dans les dossier nommé à partir de leur id.

Documentation/docs/frontend/functionning.md

+# Fonctionnement
+
+## Structure du frontend
+
+Lorsqu'on accède à l'application, on va tomber sur la page suivante(/home-project):
+![Home Project Page](./img/home-project-page.png)
+
+On aura la possibilité d'ajouter différents projets, les supprimer ou bien modifier les process associé au projet. On aura également le bouton en haut à gauche *PROCESS* qui permettra d'importer des process sans créer un projet. Cet page est modifiable dans les fichiers du projet ionic, dans le répertoire *meshprocess/src/app/home-project*.
+Chaque page ionic est structuré de cette façon:  
+![Page structure](./img/page-structure.png)
+
+### Modification du comportement de la page
+Comme pour une page html normal, on peut modifier le design de la page dans le **html** et le **scss**. La logique de notre page, se situe dans le fichier typescript qui dans l'exemple ici: *home-project-page.ts* 
+
+
+### Structure d'un projet
+Dans ce même dossier ici dans notre page contenant les projets, on a également le fichier *project-model.ts*, qui va contenir ici la classe pour représenter la structure qu'un projet peut avoir:  
+![Project structure](./img/projet-structure.png)  
+ Cela nous est utile pour pouvoir accéder aux attributs d'un projet plus facilement.
+
+### Structure d'un process
+La structure d'un process est lui également situé dans un fichier en particulier *meshprocess/src/app/dashboard/process-model.ts*:  
+![Process structure](./img/process-structure.png)  
+
+
+
+## Visualisation des process
+
+### Structure de la page
+La page pour visualiser les process de chaque projet est représenter comme ci-dessous:  
+![Dashboard Page](./img/dashboard-page.png)
+
+Sur cet page on pourra comme pour les projets ajouter un nouveaux process. 
+
+###  Ajout d'un process
+
+La particularité est qu'on devra communiquer avec notre backend Django pour pouvoir faire la conversion d'un fichier step à importer. Dans notre cas le fichier step sera converti et le backend nous enverra un *json* contenant le contenu du fichier *obj*. Le contenu de ce *json* va être stocké dans l'attribut *dataObj* de chaque process et permettra de l'afficher dans babylonjs
+
+### Affichage d'un objet 3d
+
+Pour afficher le process on utilise la librairie *babylonjs*. *babylonjs* nous permet directement de générer l'aperçu 3d d'une pièce directement à partir du contenu du fichier *obj*. Et puisque dans notre cas, on a directement les données *obj*. On pourra a chaque fois qu'on voudra afficher une pièce en particulier, le générer rapidement.
+
+### Image de chaque process
+
+À chaque ajout d'un nouveau process, la pièce est directement visualisable sur le côté droit de la page. Grâce à la librairie *babylonjs*, on récupère directement une image de la pièce lors de sa génération, et c'est cette image la qui sera stocké dans notre *Firebase*. 
+
+### Rendu de la visualisation d'une pièce
+
+Lors qu'on voudra visualiser une pièce, plusieurs informations seront disponibles pour voir les différentes particularités de la pièce:
+
+![Visualisation ](./img/visu-babylon.png)
+
+Ici on a utiliser les GUI de babylonjs pour pouvoir visualiser la pièce de manière optimale pour l'utilisateur.

Documentation/docs/frontend/index.md

+# Frontend
+
+Cette page contient la documentation concernant la partie frontend du projet.
+
+Le framework [Ionic](https://ionicframework.com/), avec [Angular](https://angular.io/) et 
+[Tailwind CSS](https://tailwindcss.com/) est utilisé pour le frontend du projet.
+
+
+## Installation
+
+La marche à suivre pour l'installation et la mise en place du projet est disponible sur le 
+[gitlab](https://gitedu.hesge.ch/in-code-we-trust/frontend/-/blob/main/README.md#installation).

Documentation/docs/frontend/ionic.md

+# Ionic
+
+## Création d'un nouvel élément ionic
+
+Dans *ionic* on peut créer un nouvel élement facilement(page, service, component, etc...). Il suffit d'exécuter la commande suivante:  
+```bash
+ionic generate
+``` 
+
+Puis il faut juste choisir l'élément à génerer dans le projet ionic et les fichiers nécessaires seront créé automatiquement en conséquence.