Voir la source de Développement d'une base de donnée

__TOC__
<br style="clear: both;"/>

=Présentation générale=
* '''Nom du projet :''' Développement d'une base de donnée

* '''Stagiaire :''' Fabien DI NATALE

=Projet=

==Le sujet==

Nous devons créer une base de données dont le but sera de regrouper tous les objets connectés au réseau et de pouvoir les retrouver par des requêtages spécifique. Nous pourrons rechercher les objets connectés par Caractéristiques, par nom ou par FCC_ID. Cette base de données devra être accessible et modifiable par une application web codée en java. Nous ne devons pas sous estimer la possibilité d’une augmentation exponentiel des données en cas d’utilisation de notre projet à plus grande ampleur. Sans oublier la protection des données.

Chaque objets connectés comportera les champs suivants: 
* son FCC_ID,
* son nom,
* son mode de communication,
* sa marque,
* sa version,
* ses caractéristiques, 
* ses failles de sécurité.

==Cahier des charges==
'''Contexte :''' 
Énormément d’objets connectés sont utilisé dans le monde mais aucune base de données n'est régis par l’IRCICA

'''Objectif :''' 
Créer un serveur web relié à une base de données capable de gérer une grande quantité d’objets connectés et accessible à travers le monde recensent toutes les caractéristiques ainsi que toutes les failles de sécuritées de ces objets.

'''Besoins fonctionnels :''' 
Nous avons besoin que cette base de données soit facilement et rapidement modifiable, accessible et la plus résistante possible aux différentes cyber attaques.
Nos objets pourront être recherché par leur FCC_ID qui est unique pour chaque objets, par leur nom ou par les caractéristiques qu'ils possèdent. De plus notre base de données devrat être capable de recenser toute les failles de sécuritées connu de chaque objets connectés. Ces failles pourront être ajoutée à tout moment, il suffirat d'afficher l'objets et d'ajouter la faille.

'''Contraintes :''' 
Le serveur web doit être développé en Java avec la possibilité de monter en charge rapidement.

'''Résultats attendus :''' 
Une application web protégé et accessible avec une grande efficacité de recherche et de modification des données.

'''Exigences :''' 
Nous devons avoir notre base de données ainsi que notre application web bien protégé contre les cyber attaques.

=Informations importantes=

==Les Bases de données==

Pour commencer voici les différents type de base de données:


*Les bases de données relationnel: 

Les bases de données relationnel sont les bases de données de référence, les plus anciennes et les plus utilisées, elles possèdent toute le même language le SQL. Celles ci permettent une grande rapidité de traitement et la possibilité de gérer de grand volume. Cependant les bases de données relationnel sont très strict dans leur conception et une fois faite elles ne peuvent plus être modifiées. De plus chaque membres d'une table doit posséder les attributs avec lesquels la table a était créé.


*Les bases de données orientées clé-valeur:

Ces bases de données reliant simplement une clé à une valeur sont des bases de données très rapide, ce sont les bases de données les plus rapide en terme de recherche et d'accés aux données mais sont limité dans la formation des données et la gestion de requête sophistiqué.


*Les bases de données orientée documents:

Ces bases de données sont l'évolution des bases de données clé-valeur ajoutant certains avantages comme une structure très libre contrairement aux structure clé-valeur se limitant à une clé pour une valeur. 
Ces bases de données permettent des recherches plus sophisitiqué et peuvent enregistrer des structures extrèmements variée au sein de la même base de donnée. Ceci lui fait perdre un peu de rapidité par rapport aux bases de données clé-valeur. Cependant les bases de données orientée documents reste très performante et très rapide.


*Les bases de données orientée collones : 

Ces bases de données sont orientées collones, elles peuvent ainsi modifier toutes les données à l'aide d'une seule commande très rapidement. 
Ces bases de données permettent l'ajout d'un attribut très rapidement. Ces bases de données sont alors recherché et utilisé pour leur capacité à monter en charge et à acceuillir une forte volumétrie de données.


*Les bases de données à index inversé:

Ces bases de données font appel aux même principes que les bases de données orientées documents tout en profitant d'excellentes capacité de requêtage, ce système de BDD a était popularisé par google et est donc très puissant pour les recherches en milieu de texte mais ceci augmente le temps d'insertion de nouvelles données.


Comme nous avons pu le voir plus haut notre base de données a besoin de pouvoir faire des recherches rapide, simple et organisé tout en restant rapide dans la modification et l'ajout de données à notre base de données. 
Nous voulons aussi que la base de données nous donne la possibilité de modifier facilement les structures de données déjà présente. 
J'ai alors choisi l'utilisation d'une base de données orientées documents.


'''Couchbase:'''

Cette base de données orientées documents privilégie la cohérence des données aux performances pures. Couchbase dispose d'un outil de requêtage normalisé SQL appelé N1QL. Couchbase vise les applications web et peut être utilisé sur mobile. Possibilité d'utiliser les jointures à l'aide du language N1QL. Couchbase est très proche de CouchDB. BDD orientée clé-valeur et documents, fait un mix des deux pour rendre le plus polyvalent possible. 


'''MongoDB:'''

Moteur orientées documents reconnu pour la souplesse de sa structure. Il reste très souple, pas besoin de préstructurer les données il suffit de créer des collections d'y mettre des éléments sans avoir besoin de dire comment les organiser. Tout en répondant à 80% des besoins couverts par une base relationnelle traditionnelle, à l'exception du transactionnel.
Ce moteur s'appuie sur la technique json. Recherche rapide et puissante mais pas de fonction join donc pas de table de jointure.

J'ai fait le choix d'utiliser la base de données MongoDB car c'est une base de données très performante et très souple possédant une énorme communautée et donc énormément de documentation, tutoriel et peu de bug. De plus, MongoDB profite d'un driver très bien aboutit pour la programmation java nous permettant alors de manipuler toute les bases de données facilement tout en respectant notre cahier des charges.

==MongoDB==

MongoDB est une base de données noSQL ce qui signifie n'utilisant pas le language de communication ainsi que les requêtes SQL. Ce n'est donc pas une base de données relationnel comme on a l'habitude de voir mais une base de données orienté documents. 

Cette orientation document lui donne plusieurs avantage comme :
*une grande simplicité;
*une grande souplesse ;
*une grande évolutivité.

De plus MongoDB propose les fonctionnalités suivantes:
*la réplication lui permettant de dupliquer les serveurs de base de données pour répondre à une monté en charge rapide tout en augmantant sa tolérance aux pannes;
*le Sharding lui permettant de répartir les données sur plusieurs serveurs afin d'augmenter les performances ou de répartir les données géographiquement;
*un système d’information géographique permettant de manipuler simplement des positions sur un plan ou sur le globe terrestre;
*un système de recherche optimisé en fonction de la langue utilisée.


MongoDB utilise les fichiers JSON pour gérer ses données rendant ainsi les fichiers facilement manipulable et modifiable. 
Les bases de données MongoDB sont alors utilisées lorsque les systèmes ont besoin de prévoir une montée en charge rapide, ayant besoin de schéma souple et facilement reconfigurable, ayant besoin d'une répartition géographique des données ou encore une base de données ayant besoin de système de recherche, de stockage de fichier ou d’un système d'information géographique.

==Java EE==

Le terme « Java EE » signifie Java Enterprise Edition, et était anciennement raccourci en « J2EE ». Il fait quant à lui référence à une extension de la plate-forme standard. Autrement dit, la plate-forme Java EE est construite sur le langage Java et la plate-forme Java SE, et elle y ajoute un grand nombre de bibliothèques remplissant tout un tas de fonctionnalités que la plate-forme standard ne remplit pas d'origine. L'objectif majeur de Java EE est de faciliter le développement d'applications web robustes et distribuées, déployées et exécutées sur un serveur d'applications. 
Java EE a était très longtemps déprécié par sa complexité menant même à la naissance du framework Spring visant à remplacer Java EE trop complexe à prendre en main mais Java EE a su évoluer et se simplifier tandisque Spring se compléxifié. 


Java EE se distingue de ses concurents par la prise en charge de toute les bibliothèques standard répondant à la plupart des besoins ainsi que des bibliothèques logicielles additionnelles dédiées à des applications professionnelles, facilitant par exemple le développement d'applications pour des architectures distribuées. 


Aujourd'hui confié par Oracle à la fondation éclipse et maintenant appelé Jakarta EE, il dispose d'énormément de composants. En particulier des API ainsi que des composants orientés développement web tel que les Servlets qui est le controller dans les modèles MVC des sites web. Il possédes aussi des framexork web ainsi que des bibliothèques de balises tel que les JavaServer Pages (JSP), les Java Standard Tag Library (JSTL) et les JavaServer Faces (JSF).

=Mise en œuvre=

==Manipulation des données MongoDB à l'aide d'une application java==

===Logiciel et librairie utilisé===

Afin d'apprendre à manipuler MongoDB et que cela corresponde bien à notre cahier des charges nous avons utilisé les logiciels suivant:

MongoDB:
*mongo-tools        
*:collection of tools for administering MongoDB servers
*mongodb-org        
*:MongoDB open source document-oriented database system (metapackage)
*mongodb-org-mongos 
*:MongoDB sharded cluster query router
*mongodb-org-server 
*:MongoDB database server
*mongodb-org-shell  
*:MongoDB shell client

API java :
*MongoDB driver

Afin d'utiliser l'API MongoDB driver nous avons installé maven et intégré la dépendance suivante :

 <dependencies>
     <dependency>
         <groupId>org.mongodb</groupId>
         <artifactId>mongodb-driver-sync</artifactId>
         <version>3.10.1</version>
     </dependency>
 </dependencies>

===Développement de l'application de gestion java===

Afin de gérer la base de données MongoDB nous avons choisi d'utiliser le language de programmation java.

Afin de répondre au cahier des charges et intégrer les fonctions au serveur web par la suite,

voici les fonctions a réaliser : 
*afficher les objets connectés;
*afficher les caractéristiques;
*recherche d'un objet connecté par nom;
*ajout d'un objet connecté;
*ajout d'une caractéristique;
*recherche d'un objet connecté par FCC_ID;
*listage des objets connectés par caracteristique;
*ajouter une caracteristique à un objet connecté;
*ajouter une faille à un objet connecté ;
*supprimer une caracteristique d'un objet connecté;
*supprimer une faille d'un objet connecté;
*supprimer un objet connecté.


Afin d'expliquer au mieux ce code sans que cela soit trop rébarbatif je vais vous présenter quelque fonctions : 

Pour commencer voici une fonction de recherche, ici celle de recherche par nom:

    static List<IOT> recherche_IOTs_nom(MongoCollection c, String name) throws NullPointerException, Exception{
        /*Créé la requête de recherche spécifiant que l'on recherche tout document comportant notre 
        entrée seul, en début, en fin ou en milieu de mot/phrases dans le champ nommée nom*/
        BasicDBObject textSearch = new BasicDBObject("nom", new BasicDBObject("$regex", ".*"+name+".*"));
        FindIterable findIterable; 
        try{
            findIterable = c.find(textSearch);
        }catch(Exception e){
            throw new Exception("Impossible d'accéder à la base de données des objets");
        }
        if(findIterable == null){
            throw new NullPointerException("Aucun élément de la base de données correspond au nom entré");
        }
        List<IOT> r = new ArrayList<IOT>();
        /*Liste les objets trouvé à partir de leur documents*/
        MongoCursor<Document> it;
        try{
            it = findIterable.iterator();
        }catch(Exception e){
            throw new Exception("Impossible d'accéder à la base de données des objets");
        }
        if(!it.hasNext()){
            throw new NullPointerException("Aucun élément de la base de données correspond au nom entré");
        }
        while(it.hasNext()){
            Document doc = it.next();
            Commune fonction = new Commune();
            r.add(fonction.Recuperation_BDD_IOT_V2(doc));
        }
        return r;
    }

Dans cette fonction nous déterminons l'object de recherche à l'aide de regex permettant une recherche souple, c'est à dire que tous les documents comportant dans leur attribut nom le String name, qu'il soit parfaitement identique ou noyé au milieu d'une longue phrase seront retournés.
Nous allons ensuite vérifier que nous avons bien un document correspondant à la recherche puis nous récupérons les informations à l'aide d'une fonction de récupération des objets nommée Recuperation_BDD_IOT_V2. Nous retournons enfin la liste des Objets trouvés sous forme de ArrayList.

Cette fonction Recuperation_BDD_IOT_V2 est basé sur le même fonctionnement que la fonction suivante :

    public caracteristique Recuperation_BDD_caracteristique(Document doc) {
        List list = new ArrayList(doc.values());
        if(list.size() < 1){
            return null;
        }
        String id_s = list.get(0).toString();
        String name = (String) list.get(1); 
        String description = null;
        try{
            description = (String) list.get(2);
        }
        catch(IndexOutOfBoundsException e){
            description = null;
        }
        int info_dim = 0;
        try{
            info_dim = (int) list.get(3);
        }
        catch(IndexOutOfBoundsException e){
            info_dim = 0;
        }        
        caracteristique c = new caracteristique();
        c.setID(id_s);
        c.setNom(name);
        c.setDescription(description);
        try{
            c.setNb_dim(info_dim);
        }catch(Exception e){
            c.setNb_dim(0);
        }
        return c;
    }

Nous prenons un document en entrée, on lui fait subir un cast pour en faire une list et ensuite nous utilisons la méthode get afin de récupérer les différents champs du document en faisant bien attention aux exceptions IndexOutOfBoundsException qui apparaisse assez souvent car à cause de la flexibilité de mongoDB les documents ne sont pas tous de la même taille rendant alors les fonctions de récupération assez longue.


Nous allons maintenant voir comment ajouter un objet ainsi qu'une caractéristique dans la base de données :

    public void add_BDD(MongoCollection collection, IOT i){
        /*Création du document regroupant toute les informations de l'objet pour l'intégrer à la base de données */
        Document newDoc = new Document();
        newDoc.append("FCC_ID", i.getFCC_ID());
        newDoc.append("nom", i.getNom());
        newDoc.append("MDC", i.getMDC());
        newDoc.append("marque", i.getMarque());
        newDoc.append("version", i.getVersion());
        newDoc.append("nbr_caracteristique", i.getNbr_caracteristique());
        List<caracteristique_objet> caracteristiques = i.getCaracteristiques();
        caracteristique_objet c = caracteristiques.get(0);
        /*Création du document de la première caractéristique*/
        Document caracteristique = new Document();
        caracteristique.append("nom", c.getNom());
        caracteristique.append("description", c.getDescription());
        caracteristique.append("nb_dimension", c.getNb_dim());
        int[] dims = c.getDimension();
        int place = 1;
        if(c.getNb_dim() > 0){
            for(int num:dims){
                String nom = "dimension_" + place;
                place++;
                caracteristique.append(nom, num);
            }
        }
        /*Insertion de ce document pour permettre de faire un tableau*/
        if(i.getNbr_caracteristique() > 0){
            newDoc.append("caracteristique", singletonList(caracteristique));
        }
        /*Envoie de toute les informations à la base de données*/
        collection.insertOne(newDoc);
        BasicDBObject searchQuery = new BasicDBObject("FCC_ID", i.getFCC_ID());
        /*Ajout de toute les caractéristiques au tableau */
        for(int j = 1 ; j < i.getNbr_caracteristique() ; j++){
            Document newDoc2 = new Document();
            c = caracteristiques.get(j);
            caracteristique = new Document();
            caracteristique.append("nom", c.getNom());
            caracteristique.append("description", c.getDescription());
            caracteristique.append("nb_dimension", c.getNb_dim());
            dims = c.getDimension();
            place = 1;
            if(c.getNb_dim() > 0){
                for(int num:dims){
                    String nom = "dimension_" + place;
                    place++;
                    caracteristique.append(nom, num);
                }
            }
            newDoc2.append("$push",new Document().append("caracteristique",caracteristique));
            collection.updateOne(searchQuery, newDoc2, new UpdateOptions().upsert(true));
        }
        /*Ajout du nombre de faille en préparation à l'ajout de faille dans le futur*/
        Document Doc = new Document().append("nbr_faille", i.getNbr_faille());
        Doc = new Document().append("$set", Doc);
        collection.updateOne(searchQuery, Doc, new UpdateOptions().upsert(true));
    }

Dans cette fonction nous créont un Document dans lequel nous ajoutons tous les attributs de notre objet les un après les autres tout en créant un tableau de string pour les caractéristiques et les failles, ces tableaux pourront être de n'importequelle taille d'où les deux attributs : nbr_caracteristique et nbr_faille facilitant leur lecture.

Pour finir nous pouvons voir comment l'ajout de caractéristique ce fait, donc voici la fonction qui s'en occupe :

    public IOT add_caracteristique(MongoCollection collection, caracteristique_objet c, IOT i)throws Exception{
        /*Modifie le nombre de caractéristiques que possède l'objet */
        i.setNbr_caracteristique(i.getNbr_caracteristique()+1);
        /*Récupère toute les caractéristiques de l'objet et ajoute celle que l'on veux ajouter à cette liste*/
        List<caracteristique_objet> caras = i.getCaracteristiques();
        caras.add(c);
        /*Modifie l'objet manipulé*/
        i.setCaracteristiques(caras);
        
        /*Créé le document de recherche qui nous permettra de sélectionner le bon objet lors de la modification*/
        BasicDBObject searchQuery = new BasicDBObject("FCC_ID", i.getFCC_ID());
        Document newDoc = new Document();
        Document Doc = new Document();
        newDoc.append("nbr_caracteristique", i.getNbr_caracteristique());
        newDoc = new Document().append("$set", newDoc);
        /*Modifie le nombre de caractéristiques que possède l'objet dans la base de données*/
        collection.updateOne(searchQuery, newDoc, new UpdateOptions().upsert(true));
        /*Créé le document qui va être ajouté à la base de donnée */
        Document caracteristique = new Document();
        caracteristique.append("nom", c.getNom());
        caracteristique.append("description", c.getDescription());
        caracteristique.append("nb_dimension", c.getNb_dim());
        int[] dims = c.getDimension();
        int place = 1;
        if(c.getNb_dim() > 0){
            for(int num:dims){
                String nom = "dimension_" + place;
                place++;
                caracteristique.append(nom, num);
            }
        }
        /*Ajoute le document en fin de tableau des caractéristiques */
        newDoc.put("$push",new Document().append("caracteristique", caracteristique));
        try{
            /*Met à jour la base de données*/
            collection.updateOne(searchQuery, Doc, new UpdateOptions().upsert(true));
            collection.updateOne(searchQuery, newDoc, new UpdateOptions().upsert(true));
            resultat = "Ajout de la caracteristique "+ c + " avec succès";
        }
        catch(MongoException e){
            i.setNbr_caracteristique(i.getNbr_caracteristique()-1);
            caras = i.getCaracteristiques();
            caras.remove(c);
            i.setCaracteristiques(caras);
            throw new Exception();
        }
        return i;
    }

Nous pouvons identifier le searchQuery permettant de sélectionner l'objet souhaité et le newDoc qui dans un premier temps met à jour le nombre de caracteristiques que l'objet possède avec la commande $set et dans un second temps ajoute le nom de la caractéristique au tableau des caractéristiques avec la commande $push.

Maintenant que toutes ces fonctions sont fonctionnel et vérifié à l'aide du script shell MongoDB nous pouvons passer à la partie serveur web du projet.

==Développement de l'application web en java==

===Logiciel et librairie utilisé===

Afin de créer le plus proprement et le plus facilement possible notre serveur web nous avons fait le choix d'installer un IDE: netbeansIDE qui s'est avéré très pratique pour l'utilisation de maven et l'intégration des accès aux bases de données MongoDB dans notre serveur Web.

Nous avons ajouté la dépendance suivante :

 <dependency>
     <groupId>javax</groupId>
     <artifactId>javaee-web-api</artifactId>
     <version>6.0</version>
     <scope>provided</scope>
 </dependency>

Dans cette partie du code nous avons seulement ajouté les librairie implémenter par le framework java EE au librairie de mongoDB que nous avons eu l'occasion d'utiliser précédemment.

===Modèle utilisé===

Afin de réaliser ce projet je me suis orienté vers un modèle de serveur web spécifique, le modèle MVC.

Ce modèle décrit une architecture précise comportant trois parties : La partie Modèle , la partie Vue et la partie Contrôleur pour MVC.
La partie Modèle est la partie encapsulant la logique métier ainsi que l'accès aux donner. Cette partie de l'architecture sera représenté par nos classes métier.
La partie Vue s'occupe de toute les interactions avec l'utilisateur donc ici ça sera toute nos page web écrit en JSP.
La partie Contrôleur gère le liens entre l'utilisateur et le reste de l'application, ici nous gérerons ce lien à l'aide des Servlets.

Ce modèle permet d'avoir une séparation claire des différentes partie du code même si ceci augmente la complexité de l'architecture de notre serveur web. Nous pouvons donc avoir dans notre serveur web trois partie très distincte représentant les trois parties du modèle MVC avec en appuie quelque classes rassemblé sous un package bean représentant les différentes classes que nous allons manipuler dans les trois partie.


===Développement du serveur web java EE===

Grâce à l'utilisation du modèle MVC que l'on a pu décourvrir précédemment nous pouvons décrire notre code en 4 partie : 

*Les pages JSP (La partie Vue)
*Les Servlets (La partie Contrôleur)
*Les beans
*Les classes métier (La partie Modèle)

====Les pages JSP====


*'''Acceuil.jsp :''' Cette page est la page d'acceuil, la première page qui est censé s'afficher après la connexion. Rien de particulié n'est afficher sur la page, cependant la servlet derrière la page permet toute l'initialisation de la session et ainsi tout utilisateur doit passer par cette page pour accéder à notre site et pouvoir l'utiliser proprement.


*'''Affichage_caracteristique.jsp :''' Cette page affiche toute les caractéristiques présente dans la base de données avec leur description par défault et le nombre de valeur dont elles ont besoin pour être initialisé


*'''Ajout_image.jsp :''' Celle ci est faite pour ajouter des images à notre base de données pour ensuite les afficher dans la description de nos objets connectés


*'''Bandeau.jsp :''' Cette page est une page que l'on appelle jamais seule mais que l'on inclue à toute les autre, celle ci permet d'afficher en haut de page tous les liens important du site, c'est un menu.


*'''Affichage.jsp :''' Cette page JSP affiche le bandeau puis soit affiche une erreur si elle existe soit affiche l'objets connecté qui lui a était passé en attribut.


*'''Affichage_IOT.jsp :''' Cette page JSP est comme le bandeau, jamais affiché seule mais souvent import. Celle ci permet de simplement avec un import afficher toute les caractéristiques d'un objet ainsi que les liens nécessaire pour le modifier.


*'''Affichage_multiple_IOT.jsp :''' Cette page JSP est identique à la page Affichage_IOT.jsp à la différence qu'il y a moins d'information sur les objets, pas les liens de modification mais un seul lien vers l'affichage complet de l'objet. Celle ci permet l'affichage d'une liste d'objet avec les informations minimale réquise. Ceci permet aussi une modification plus facile et permet une adaptation selon comment nous voulons faire évoluer le site par la suite.


*'''Ajout_caracteristique.jsp :''' Cette page est accessible seulement par un lien défini dans affichage_IOT.jsp, il permet d'ajouter une caractéristique à un objet, présente dans la base de données des caractéristiques mais que l'objet ne possède pas. Cet ajout renvoie alors sur une page remplissage_caracteristique_simple.jsp qui permet de finaliser l'ajout de la caractéristique.


*'''Remplissage_caractéristique_simple.jsp''' permet donc de modifier la description de la caractéristique et de rentrer les valeurs de la caractéristique si celle ci en a besoin. 
	

*'''Formulaire_interface.jsp :''' Comme son nom l'indique nous somme ici dans un fichier formulaire, ce formulaire permet d'entré de nouveaux objets dans la base de données avec tous les attributs caractérisants. Pour valider ces nouveaux objets, cette page renvoie sur la page remplissage_caracteristique.jsp.


*'''Remplissage_caracteristique.jsp :''' Cette page est basé sur le même principe que la page remplissage_caracteristique_simple.jsp à la différence que celle ci s'occupe de toute les caractéristiques qui ont était sélectionner au paravant dans le formulaire Formulaire_interface.jsp


*'''Rechercher_ID.jsp :''' Cette page est simplement une page de recherche récupérant le FCC_ID de l'objet recherché afin de l'afficher ou d'afficher le résultat d'erreur à l'aide de la page resultat_ID.jsp


*'''Resultat_ID.jsp :''' Affiche l'objet en  cas de réussite et le message d'erreur en cas d'erreur


*'''Rechercher_caracteristique.jsp :''' Cette page nous offre la possibilité de sélectionner une liste de caractéristique parmi toute celle présente dans la base de données dans le but de trouver tous les objets possédant toute les caractéristiques sélectionné. 


*'''Resultat_caracteristique.jsp :''' Cette page à pour mission d'afficher les objets à condition que la liste d'objet n'est pas vide. Si elle est vide nous avons alors l'affichage d'un message d'erreurs avec une liste des caractéristiques choisie n'ayant mené à aucun objet.


*'''Rechercher_nom.jsp :''' Cette page est simplement une page de recherche récupérant le nom de l'objet recherché afin d'afficher tous les objet ayant le nom rentrée compris dans leur nom, c'est une recherche souple permettant une recherche sur tous les objets sans en connaître la référence exacte. Cette recherche nous renvoie alors sur la page Resultat_nom.jsp


*'''Resultat_nom.jsp :''' Cette page affiche soit le message d'erreur soit la liste des objets correspondant à la recherche effectué.


====Les Servlets====


*'''Affichage.java :''' 
**La méthode get de la servlet permet de sélectionner grace au parametre place passé directement dans l'url à partir des pages important la page Affichage_IOT_multiple.jsp . Cet objet est ensuite utilisé pour récupérer les liens de ses images pour enfin être envoyé vers la page d'affichage.
**La méthode post récupère l'objet envoyé pour récupérer les liens vers ses images correspondante et renvoie le tout vers affichage.jsp pour afficher. 


*'''Affichage_caracteristique.java :''' 
**La partie get de la servlet s'occupe de récupérer toute les caractéristiques présente dans la base de données des caractéristiques et envoie ces information à la page affichage_caracteristique.jsp
**La partie Post s'occupe de vérifier que la nouvelle caractéristique entré possède bien toute les informations nécessaire et si elles sont juste avant de retourner à l'affichage de toute les caractéristiques.


*'''Ajout_caracteristique.java :''' 
**La partie get procède à la récupération de toute les caractéristiques présente dans la base de données puis récupère les caractéristiques présente dans l'objet puis en fait la différence pour ressortir seulement les caractéristiques que l'on peut ajouter pour enfin envoyer cette liste à la page ajout_caracteristique.jsp.
**La partie Post marche en deux passage, le premier il récupère les informations de la caractéristique que l'utilisateur souhaite ajouter puis vérifie qu'il n'y a pas eu d'erreur, si il y a eu une erreur on refait la même chose que pour la partie get plus affiche le message d'erreur et en cas de réussite on part sur la page remplissage_caracteristique_simple.jsp afin de récupérer les dernières informations. Le second passage vérifie la validité des entrées et ajoute la caractéristique à l'objet tout en mettant à jour la base de données et renvoie le tout vers l'affichage.


*'''Ajout_faille.java :''' 
**Ne possède pas de méthode get. 
**La méthode post récupère les informations de l'objet vérifie les champs entrées et ajoute la faille à l'objet tout en mettant à jour la base de données. Une fois que ceci est fait on récupère les photos ainsi que l'objet résultant et on renvoie vers la page d'affichage.


*'''Ajout_image.java :''' 
**La partie get envoie sur la page Ajout_image.jsp qui est le formulaire d'ajout de fichier. 
**La partie Post récupère le chemin en paramètre de servlet pour enregistrer l'image en fonction de celui ci puis une fois l'image enregistré renvoie l'utilisateur vers l'affichage de l'objet en cas de bon fonctionnement. En cas d'erreur l'utilisateur est renvoyé vers la page Ajout_image.jsp.


*'''Download.java :'''
**La partie get récupère le fichier en fonction de l'URL entrée et l'envoie en téléchargement à l'utilisateur.
**Ne possède pas de méthode Post

*'''Nouvelle_interface.java :''' 
**La partie get récupère toute les caractéristiques présente dans la base de données des caractéristiques et les envoie à la page formulaire_interface.
**La partie post récupère toutes les informations rentrées par l'utilisateur, si toute les informations sont la l'objet est alors créé puis affiché sinon la méthode post renvoie l'utilisateur vers le remplissage des caractéristiques car le problème ne peux venir que des entrée dans la page remplissage_caracteristique.jsp car la première partie du formulaire est géré par la servlet remplissage_caractéristique.java.


*'''Remplissage_caracteristique.java :''' 
**Ne possède pas de méthode get.
**La méthode post permet de vérifier toutes les entrées du formulaire de la page formulaire_interface.jsp. Une fois la vérification faite, il renvoie l'utilisateur vers le formulaire en cas d'erreur sinon il envoie l'utilisateur sur la page remplissage_caracteristique afin qu'il puisse spécifier les caractéristiques de son objet.


*'''Recherche_ID.java :''' 
**La méthode get envoie simplement l'utilisateur vers la page rechercher_ID.jsp. 
**La méthode Post prend en compte l'entrée du formulaire, la vérifie et retourne soit sur le formulaire en cas d'erreur soit sur l'affichage de l'objet récupéré en cas de succés.


*'''Recherche_par_caracteristique.java :''' 
**La méthode get récupère toute les caractéristiques présente dans la base de données des caractéristiques pour les envoyer à la page rechercher_caracteristique.jsp. 
**La méthode post récupère les caractéristiques qui ont était sélectionné puis récupère les objets correspondant aux caractéristiques sélectionné puis les envoie vers la page d'affichage resultat_caracteristique.jsp.


*'''home.java :''' 
**La méthode get permet l'authentification du client au près de la base de donnée et ainsi récupérer les portes d'accès à ces deux bases de données (celle des objets et celle des caractéristiques) et enregistre ces points d'accès dans la session afin qu'il y ai une porte d'accès par client. Le client est ensuite envoyé ver la page d'acceuil.
**Ne possède pas de méthode post. 


*'''Recherche_par_nom :''' 
**La méthode Get envoie l'utilisateur vers la page du formulaire pour rentrer le nom à rechercher.
**La méthode Post permet de récupérer la liste des objets correspondant au nom que l'utilisateur à entré sans oublier le message d'erreurs en cas d'échec.


====Les beans====


*'''Fichier.java :''' Ce bean à deux champs, nom et FCC_ID permettant d'enregistrer, de télécharger et d'organiser les différentes photos de la base de données. Le FCC_ID permet de connaître le sous-dossier où sauvegarder le fichier (ici l'image). 


*'''IOT.java :''' Ce bean recense tous les champs d'information d'un objet connecté, son FCC_ID qui est unique, son nom, son mode de communication, sa marque, sa version actuel, son nombre de caractéristique avec une liste de toute ses caractéristique (liste d'objet : caracteristique_objet) ainsi que son nombre de faille et une liste string recensent toute ses failles.


*'''caracteristique_objet.java :''' Ce bean recense toute les informations dont un objet à besoin, il est composé du nom de la caractéristique, de sa description, de son nombre de dimensions et de ses dimensions.


*'''caracteristique.java :''' Celui ci recense toute les informations dont une caractéristique en provenance ou à destination de la base de données exclusive aux caractéristique, a besoin avec son ID, son nom, sa description par défault, son nombre de dimension et le minimum et le maximum qui est recensé dans les objets. Ces minimum et maximum seront à utiliser lorsque nous voudront utiliser une recherche par caractéristique avec des dimensions dont on voudra ajouter des plages de recherche.


Ce dernier document est un peu particulier, ce n'est pas un bean mais est utilisé dans les servlets ainsi que les classes métier, il fait un lien entre les deux et est destinée à être utilisé dans les classes métier comme dans les servlets tout comme les beans vu précédemment. J'ai donc décidé de mettre ce fichier parmi les beans.

*'''Commune.java :''' Cet objet est l'objet permettant de rassembler toute les fonctions qui sont utiliser plusieurs fois. Pour l'instant nous avons 4 fonctions communes :
**''Recuperation_BDD_IOT_V2'' permettant de traduire les documents renvoyé par la commande find en objet connecté que nous pourrons manipuler plus facilement par la suite
**''Recuperation_BDD_caracteristique'' permettant de traduire les documents renvoyé par la commande find en caractéristiques que nous pourrons manipuler plus facilement par la suite
**''Listage_des_caracteristique_String'', liste toutes les caractéristiques présentes dans la base de données des caractéristiques sous forme de string, elle renvoie une liste de String qui est la liste de tout les nom des caractéristiques.
**''Listage_des_caracteristique'', liste toutes les caractéristiques présente dans la base de données des caractéristiques sous forme d'objet caractéristique facilement manipulable dans notre projet.


====Les classes métier====


*'''Ajoute_une_caracteristique.java :''' Cet objet métier est composé de 3 fonctions : 
**''ajout_caractéristique'' qui est la principale, cette fonction va faire les vérifications d'erreur, la formation des messages d'erreur, l'envoie vers les autres fonction et elle retournera le nouvel objet
**''ValidationNumber'' prenant un String en entré et rétournant un int en sortie ou une exception en cas de mauvaise entrée
**''add_caractéristique'' qui est une fonction permettant de mettre à jour la base de donnée avec le nouvel objet créé.


*'''Ajoute_une_faille.java :''' Cet objet métier est composé de 3 fonctions : 
**''ajout_faille'' qui est la fonction principale gérant les appels aux deux autres fonctions ayant pour finaliter d'ajouter une faille et de renvoyer le nouveau objet à la servlet.
**''add_faille'' permet de mettre à jour la base de données ainsi que l'objet avec la faille rentré sous forme de String
**''getValeurChamp'' permet de récupérer les paramètres de la réponse passé en paramêtre


*'''Formulaire_caracteristique.java :''' Gère le formulaire pour l'ajout de nouvels caractéristiques à la base de données des caractéristiques dans le but futur de les ajouter à certain objets. Pour ceci ce fichier métier est composé de 5 fonctions :
**''Add_caracteristique'' qui est la fonction principale gérant les appels aux autres fonctions ayant pour finaliter d'ajouter une caractéristique et de renvoyer le nouveau objet à la servlet.
**''add_BDD'' rajoute la nouvelle caractéristique à la base de données des caractéristiques
**''validationNumber'' permet de récupérer le nombre contenu dans le string passé en paramêtre ou une exception en cas d'échec
**''validationNom'' vérifie que l'entrée nom est dans les normes
**''getValeurChamp'' permet de récupérer les paramètres de la réponse passé en paramêtre


*'''Formulaire_interface.java :''' Possède une fonction de validation pour chaque champ entrée, une fonction permettant de rentrer les erreurs dans la map d'erreur qui nous sert lors de l'affichage des erreurs dans la page formulaire_interface.jsp, de plus nous avons la fonction validationNumber que l'on a pu voir précédemment accompagné de deux fonctions get permettant de récupérer les String ou les listes de String de chaque champs. Cet objet métier possède 3 autres fonctions :
**''first_step_new_IOT'' qui permet d'initialiser un nouvel objet avec les premières informations rentré dans le formulaire de départ et initialise les caractéristiques tout en vérifiant tous les champs entré. Cette fonction renvoie alors l'objet prêt à être manipulé.
**''new_IOT'' est la seconde fonction d'initialisation d'un nouvel objet, elle récupère l'objet précédemment initialisé, récupère tous les champs entré par l'utilisateur et vérifie que tout a était rentré correctement. Une fois cela fait la fonction fini l'initialisation de l'objet et lance la dernière fonction add_BDD avant de renvoyer l'objet à la servlet.
**''add_BDD'' est la fonction permettant d'ajouter un objet à la base de données des objets.


*'''Recherche_par_ID.java :''' Cet objet métier permet de renvoyer l'objet correspondant aux champs rentrée ou remplie un champ erreur en cas d'erreur lors de la recherche, pour cela nous avons la fonction de validation de champs vérifiant la validité du champs en entré, nous avons la fonction getValeurChamp vue précédemment et nous avons deux autre fonctions pour gérer cela:
**''recherche_IOT_ID'' qui créer le document de recherche fait la recherche, traduit le résultat et renvoie l'objet trouvé ou une exception
**''search_ID'' est la fonction qui relie toute les autres fonction entre elle avec la récupération et la vérification des champs, la gestion des exceptions, la récupération des informations nécessaires et fini avec le retour de l'objet trouvé.


*'''Recherche_par_caracteristique.java :''' Cet objet métier est assez similaire au précédent (recherche_par_ID.java) avec une fonction get pour récupérer toute les caractéristiques sélectionner par l'utilisateur et 3 fonctions permettant de gérer la réponse à la demande de l'utilisateur. Ici toute les fonctions de vérification ne sont pas présente car le formulaire est très restrictif et permet seulement aux utilisateurs de cocher ou décocher des éléments d'une liste.
**''Listage_des_IOT'' est une fonction retournant tous les objets présent dans la base de données des objets.
**''Listage_IOT_caracteristique'' est une fonction créant le document de recherche, effectuant la recherche dans la base de données des objets et traduisant la liste de document résultante de la recherche en liste d'objets.
**''recherche_par_cara'' est la fonction principale qui récupère la liste de caractéristique que les objets doivent posséder appelant l'une des deux autres fonctions selon la liste récupérer, gérant les exception et renvoyant enfin la liste d'objet.


*'''Recherche_par_nom.java :''' Possède une fonction getValeurChamp qui récupère et vérifie que le champ entré soit bon et deux autre fonctions : 
**''recherche_IOTs_nom'' qui est une fonction créant le document de recherche effectuant la recherche et traduisant la réponse en liste d'objets avant de renvoyer cette liste à la fonction principale.
**''recherche_nom'', la fonction principale récupérant le champ, l'appel à la fonction précédentes, la gestion des exception et le retour de la liste d'objets en réponse à la servlet.


*'''Recuperation_image.java''' possède une seule fonction, une fonction nommée recuperation_liens qui permet de lister tous les liens des images présente dans notre base de données correspondante à l'objet que la servlet manipule à ce moment la.


*'''ajout_image.java''' est composé de 4 fonctions : 
**''validationFichier'' permettant de vérifier que le fichier donné par l'utilisateur est un fichier géré par le programme
**''getNomFichier'' permet de récupérer le nom du fichier rentré par l'utilisateur
**''ecrireFichier'' permet d'enregistrer le fichier passé par l'utilisateur dans notre base de données
**''enregistreFichier'' est la fonction principale permettant d'appeler les autres fonctions les une après les autres afin que tous le processus se passe bien tout en gérant les exceptions et renvoyant les informations essentiel du fichier enregistré à la servlet.

=Source=

==Documentation==

*Les bases de données:
**[https://www.journaldunet.com/solutions/dsi/1194284-base-nosql-laquelle-choisir-pour-quels-besoins/ Comment choisir sa base de données]
**[https://www.lemagit.fr/article/NoSQL-le-choix-difficile-de-la-bonne-technologie Comment choisir sa base de données NoSQL]
**[https://sqlpro.developpez.com/cours/modelisation/metadonnees/ Présentation des métadonnées]
**[http://b3d.bdpedia.fr/couchbase.html Document Couchbase]


*MongoDB:
**[https://docs.mongodb.com/manual/tutorial/install-mongodb-on-debian/ Installer MongoDB]
**[https://www.mongodb.com/blog/post/getting-started-with-mongodb-and-java-part-i Base de la communication entre MongoDB et java]
**[https://www.mongodb.com/blog/post/mongodb-security-best-practices Réglage du serveur MongoDB]
**[https://docs.mongodb.com/manual/reference/operator/ Documentation officiel de MongoDB]
**[https://mongodb.github.io/mongo-java-driver/3.4/driver/tutorials/aggregation/ Explication de la fonction agrégation de MongoDB]
**[https://docs.mongodb.com/manual/tutorial/query-documents/ Formation des requêtes de recherche]
**[https://docs.mongodb.com/manual/reference/operator/update/ Comment mettre à jour notre base de données]


*Sécuriser le site web :
**[https://wpformation.com/wordpress-http-https/ passer de http à https]
**[https://openclassrooms.com/fr/courses/1197906-securiser-son-serveur-linux Sécuriser un serveur linux]
**[https://docs.ovh.com/fr/dedicated/securiser-un-serveur-dedie/ Sécuriser un serveur dédié]


[https://docs.oracle.com/javase/7/docs/api/index.html Documentation java officiel]

==Tutoriel==

*Manipuler les bases de données mongoDB:
**[https://openclassrooms.com/fr/courses/1915371-guide-de-demarrage-pour-utiliser-mongodb Base de la communication java/MongoDB]
**[https://fr.blog.businessdecision.com/bigdata/2017/10/tutoriel-mongodb-requetes/ Manipulation de MongoDB à l'aide du terminal]
**[https://mongodb-documentation.readthedocs.io/en/latest/ecosystem/tutorial/use-aggregation-framework-with-java-driver.html Comment utiliser l'agrégation avec java]


*Tutoriel Java EE et création du site:
**[https://developer.mozilla.org/fr/docs/Web Toute la doc précise sur les balises CSS et HTML]
**[https://openclassrooms.com/fr/courses/626954-creez-votre-application-web-avec-java-ee/618989-introduction-au-java-ee Base java ee]
**[https://openclassrooms.com/fr/courses/2434016-developpez-des-sites-web-avec-java-ee/2438571-quest-ce-que-java-ee Base java ee en vidéo]