uml

README.md

@@ -1,149 +1,162 @@
-## JaxRS + openAPI
+Front ( dans un terminale ) : cd frontend / ng serve
+Back ( un autre terminal ) : run-hsqldb-server.bat / show-hsqldb.sh / RestServer.java ( dans src / java et restserv) )
+Créer un service dans le front (rentrer dans front/service) : ng genere service service <nom>
+
+# Ticket Miagester
+
+Ce projet a été réalisé dans le cadre du cours de Systèmes d'Information Répartis (SIR), et a pour but de mettre en place une application web et mobile permettant aux utilisateurs d'acheter des tickets de concert en ligne.
+
+## Sommaire
+1. [Prérequis](#prérequis)
+2. [Installation et lancement](#Installation-et-lancement)
+3. [Structure du projet](#structure-du-projet)
+    - [Arborescence](#arborescence)
+    - [Domain](#domain)
+    - [DAO](#dao)
+    - [Service](#service)
+    - [DTO](#dto)
+    - [Ressource](#ressource)
+    - [JPATest](#JPATEST)
+    - [Swagger](#swagger)
+4. [Qualité du Code](#qualité-du-code)
+5. [Configuration](#configuration)
+6. [RestServer](#restserver)
+7. [A venir](#a-venir)
+
+## Prérequis
+   Avant de bien démarrer l'ensemble du projet, assurez-vous les éléments suivants :
+   - [java 17+](https://www.oracle.com/java/technologies/javase-jdk17-downloads.html)
+   - [maven](https://maven.apache.org/download.cgi)
+   - Un IDE compatible (IntelliJ IDEA, Eclipse, VS Code, etc.)
+
+## Installation et lancement
+Cloner le projet
+```sh
+git clone https://github.com/ChristianPeuffier/JaxRSOpenAPI.git
+cd JaxRSOpenAPI
+```
+Lancer la base de données
+```sh
+# Pour Windows
+.\run-hsqldb-server.bat
 
-1. Import this project in your IDE, 
-2. Start the database
-3. Start the database viewer
-4. Start the backend. There is a main class to start the backend
+# Pour Linux et MacOS
+./run-hsqldb-server.sh
+```
+Pour afficher la base de données
+```sh
+# Pour Windows
+.\show-hsqldb.bat
 
+# Pour Linux et MacOS
+./show-hsqldb.sh
+```
+Lancer le serveur
 
+Pour lancer le serveur, il suffit de lancer la classe
+`RestServer.java`. Cela va démarrer le serveur sur le port **8080**.
 
 
-# Task Open API Integration 
+## Structure du projet
+### Arborescence
+```
+.
+├── src
+│   ├── main
+│   │   ├── java
+│   │   │   ├── fr.istic.taa.jaxrs
+│   │   │   │   ├── dao
+│   │   │   │   ├── domain
+│   │   │   │   ├── dto
+│   │   │   │   ├── rest
+│   │   │   │   ├── service
+│   │   │   │   ├── uml
+│   │   │   │   ├── JPATest.java
+│   │   │   │   ├── RestServer.java
+│   │   │   │   ├── TestApplication.java
+│   │   ├── resources
+│   │   ├── webapp
+│   ├── pom.xml
+│   ├── README.md
+```
+### Domain
 
-Now, we would like to ensure that our API can be discovered. The OpenAPI Initiative (OAI) was created by a consortium of forward-looking industry experts who recognize the immense value of standardizing on how REST APIs are described. As an open governance structure under the Linux Foundation, the OAI is focused on creating, evolving and promoting a vendor neutral description format. 
+Pour réaliser ce projet, nous avons d'abord commencé par créer le domain, qui regroupe toutes nos classes principales permettant de modéliser les différents objets : **Utilisateur, Organisateur, Administrateur, Evenement, Stats et Ticket**.
 
-APIs form the connecting glue between modern applications. Nearly every application uses APIs to connect with corporate data sources, third party data services or other applications. Creating an open description format for API services that is vendor neutral, portable and open is critical to accelerating the vision of a truly connected world.
+Chaque classe est une **entité** qui sera créée dans notre base de données.
 
-To do this integration first, I already add a dependencies to openAPI libraries. 
+Les classes **Administrateur** et **Organisateur**, qui héritent d'**Utilisateur**, possèdent un `@DiscriminatorValue`. Elle permet d'indiquer, lors de la création d'un administrateur ou d'un organisateur, le type spécifique de l'utilisateur dans la colonne `type_utilisateur`.
 
-```xml
-		<dependency>
-			<groupId>io.swagger.core.v3</groupId>
-			<artifactId>swagger-jaxrs2-jakarta</artifactId>
-			<version>2.2.15</version>
-		</dependency>
+Il y a également une énumération **StatutTicket** qui permet de définir les différents statuts d'un ticket.
 
-		<dependency>
-			<groupId>io.swagger.core.v3</groupId>
-			<artifactId>swagger-jaxrs2-servlet-initializer-v2</artifactId>
-			<version>2.2.15</version>
-		</dependency>
-```
+### Dao
 
-Next you have to add OpenAPI Resource to your application
+Dans un second temps, nous avons poursuivi avec la mise en place des classes **DAO.** Elles permettent d’interagir avec la base de données et d’exécuter des opérations **CRUD** sur les entités.
 
-Your application could be something like that. 
+Grâce à `extends AbstractJpaDao`, les classes bénéficient de la structure générique proposée par JPA qui permet d’effectuer des requêtes sans avoir à réécrire la logique et la persistance pour les requêtes de base, comme `find`, `findAll`, `save`, `update`, `delete`.
 
-```java
-@ApplicationPath("/")
-public class RestApplication extends Application {
+Créer ces classes nous permet également d’isoler la logique d’accès aux données et de séparer les responsabilités dans l'application.
 
-	@Override
-	public Set<Class<?>> getClasses() {
-		final Set<Class<?>> resources = new HashSet<>();
+### Service
 
+Nos classes service nous permettent de centraliser la logique métier, ce qui nous permet de créer nos différents besoins pour poursuivre l’application.
 
-		// SWAGGER endpoints
-		resources.add(OpenApiResource.class);
+Elles servent d’intermédiaire entre la couche DAO et la couche Ressource.
 
-        //Your own resources. 
-        resources.add(PersonResource.class);
-....
-		return resources;
-	}
-}
-```
+### Dto
 
-Next start your server, you must have your api description available at [http://localhost:8080/openapi.json](http://localhost:8080/openapi.json)
+La couche DTO permet de restituer uniquement les données nécessaires, contrairement à la DAO, qui retourne l’intégralité des données de l’objet.
 
-### Integrate Swagger UI. 
+Cela permet de limiter l’exposition de données sensibles et améliore la sécurité en évitant d’exposer directement la structure de la base de données.
 
-Next we have to integrate Swagger UI. We will first download it.
-https://github.com/swagger-api/swagger-ui
+Les données renvoyées sont sous un format json.
 
-Copy dist folder content in src/main/webapp/swagger in your project. 
+### Ressource
 
-Edit index.html file to automatically load your openapi.json file. 
+Les classes ressource permettent d’interagir avec la partie web. Elles interagissent avec les classes services et les requêtes HTTP des clients. On utilise les méthodes des services pour récupérer les données souhaitées.
 
-At the end of the index.html, your must have something like that.
+### JPATest
 
-```js
-   // Build a system
-      const ui = SwaggerUIBundle({
-        url: "http://localhost:8080/openapi.json",
-        dom_id: '#swagger-ui',
-
-        ...
-```
+Dans cette classe, nous avons créé des utilisateurs, des événements, etc. Par la suite, si nous avons besoin de créer de nouveaux éléments, nous passerons par Swagger, pour des raisons de simplicité.
 
-Next add a new resources to create a simple http server when your try to access to http://localhost:8080/api/.
+### Swagger
 
-This new resources can be developped as follows
+Swagger est un outil qui permet de documenter les API REST. Il permet de générer une documentation à partir des annotations JAX-RS. Il est accessible à l'adresse suivante (après avoir lancé le serveur) :
 
-```java
-package app.web.rest;
+http://localhost:8080/api/
 
-import java.io.IOException;
-import java.nio.file.FileSystems;
-import java.nio.file.Files;
-import java.util.logging.Logger;
+## Qualité du Code
 
-import javax.ws.rs.GET;
-import javax.ws.rs.Path;
-import javax.ws.rs.PathParam;
+Dans le fichier `pom.xml`, nous avons ajouté plusieurs plugins de reporting pour assurer la qualité du code. Ces plugins incluent :
 
-@Path("/api")
-public class SwaggerResource {
+- **maven-javadoc-plugin** : génère la documentation du code source.
+- **maven-pmd-plugin** : détecte les erreurs potentielles et les mauvaises pratiques.
+- **maven-checkstyle-plugin** : applique les règles de style de code.
+- **maven-jxr-plugin** : facilite la navigation dans le code source.
 
-    private static final Logger logger = Logger.getLogger(SwaggerResource.class.getName());
+Pour générer les rapports, on utilise la commande `mvn clean sit`:
 
-    @GET
-    public byte[] Get1() {
-        try {
-            return Files.readAllBytes(FileSystems.getDefault().getPath("src/main/webapp/swagger/index.html"));
-        } catch (IOException e) {
-            return null;
-        }
-    }
+On obtient le rapport sur la page html qui se trouve : `target/site/index.html`.
 
-    @GET
-    @Path("{path:.*}")
-    public byte[] Get(@PathParam("path") String path) {
-        try {
-            return Files.readAllBytes(FileSystems.getDefault().getPath("src/main/webapp/swagger/"+path));
-        } catch (IOException e) {
-            return null;
-        }
-    }
+## Configuration
 
-}
-```
+Elle permet de configurer les ressources de l’application.
 
-Add this new resources in your application
+L'annotation `@ApplicationPath("/")` définit le chemin racine de l'API, ce qui signifie que toutes les ressources seront accessibles à partir de l'URL de base du serveur.
 
-```java
-@ApplicationPath("/")
-public class RestApplication extends Application {
+Si on rajoute une classe, nous devons le spécifier ici.
 
+Grâce à ça l’app peut gérer des requêtes REST et générer la documentation pour swagger.
 
-	@Override
-	public Set<Class<?>> getClasses() {
-		final Set<Class<?>> resources = new HashSet<>();
+## RestServer
 
+La classe `RestServer` initialise et démarre un service sur le port **8080**. Elle déploie l'application `TestApplication`.
 
-		// SWAGGER endpoints
-		resources.add(OpenApiResource.class);
-		resources.add(PersonResource.class);
-        //NEW LINE TO ADD
-		resources.add(SwaggerResource.class);
+## A venir
 
-		return resources;
-	}
-}
-```
+Pour le moment la structure globale du Back-End est en place, il reste à implémenter les fonctionnalités de l'application, telles que la gestion des utilisateurs, des événements, des tickets, etc.
 
-Restart your server and access to http://localhost:8080/api/, you should access to a swagger ui instance that provides documentation on your api. 
+Dans l'idéal, il faudrait faire un premier jet du front pour pouvoir cibler les logiques métiers à implémenter.
 
-You can follow this guide to show how you can specialise the documentation through annotations.
+Il faudrait également ajouter des tests unitaires pour garantir le bon fonctionnement de l'application.
 
-https://github.com/swagger-api/swagger-samples/blob/2.0/java/java-resteasy-appclasses/src/main/java/io/swagger/sample/resource/PetResource.java