second commit

README-COPY.md

@@ -0,0 +1,123 @@
+# 1. Partie backend: application orientée microservices
+## 1.1. Introduction
+Nous mettons en place une application orientée microservices avec Spring MVC et Spring Cloud OpenFeign. Simulation d'un scénario de gestion de projets.
+
+* **Scénario nominal**: Un utilisateur est affecté à une adresse <> **Scénario alternatif**: Si l’adresse n’existe pas, erreur.
+* **Scénario nominal**: Un projet est affecté à un utilisateur et une société <> **Scénario alternatif**: Si l’utilisateur et / ou la société n’existent pas, erreur.
+* ++ des contrôles d'intégrités pour le fonctionnement de l'application.
+
+
+L’application est consistituée de deux types microservices:
+
+* Quatre microservices métiers pour le fonctionnement de l’application.
+* Deux services intermédiaires pour faire fonctionner les microservices métiers.
+
+Les répertoires des microservices métiers:
+
+* address-microservice
+* employee-microservice
+* company-microservice
+* project-microservice
+
+Les répertoires des microservices qui font fonctionner les microservices métiers:
+
+* spring-cloud-gateway-service
+* eureka-discovery-service
+
+Le répertoire de déploiement contenant un fichier docker-compose pour créer et agencer les images dockers des tous ces microservices:
+* application-deployment
+
+Chaque microservice métier possède ses propres ressources:
+
+* Sa base de données
+* Son propre code source
+* Son propre fichier de configuration
+* Ses propres dépendances
+* etc.
+
+La figure ![class diagram](https://drive.google.com/file/d/1iylBvr-rxKSOlGPnNklpHuD7RcKwk5fi/view?usp=sharing) présente le diagramme de classe de l'application.
+
+## 1.3. Communication entre microservices
+Les microservices communiquent entre eux pour le fonctionnement de l'applications.
+* **user-microservice** a besoin de **address-microservice** pour persister un utlisateur.
+- **project-microservice** a de **user-microservice** et **company-microservice** pour périsiter un projet.
+
+Pour faire communiquer les microservices, nous utilisons le pattern **Spring Cloud OpenFeign**. L'architechure d'enregistrement et de découverte des microservice de l'application backend peut se présenter ainsi: [architecture](https://drive.google.com/file/d/15pj4TvCu4DyqUZS3dLLRY7KKUgYpTBuZ/view?usp=sharing)
+
+#### Pourquoi Spring Cloud OpenFeign plutôt que Spring Boot RestTemplate?
+
+Spring Cloud OpenFeign présente plusieurs avantages:
+* Avec **RestTemplate**, un microservice qui a besoin d'appeler un autre microservice doit écrire en dur l'url de ce dernier dans son code source. **<> Spring Cloud OpenFeign** fournit l'autoconfiguration des microservices. Les microservices métiers s'enregistrent dans un service d'annuaire, un client qui a besoin de consommer un microservice métier donne le nom de ce dernier à la gateway qui le cherche à sa place. ==> le client n'a pas besoin de connâitre l'adresse complète du microservice qu'il veut consommer.
+
+* **RestTemplate** met en question l'évolutivité de l'application. En effet, RestTemplate se base sur une classe dans laquelle on écrit en dur l'url complète du microservice que l'autre microservice veut appeler. Ainsi, s'il arrive que le microservice change d'url, on est obligé de modifier le code source de la classe dans l'autre microservice qui utilise le premier microservice. **<> Spring Cloud OpenFeign** assure l'évolutivité de l'application grâce à l'autoconfiguration des microservices métiers. En effet, OpenFeign est basé sur une interface qu'il marque comme un service. Spring Cloud OpenFein avec le server d'enregistrement, permet aux microservices de s'autoenregistrer.
+
+## 1.4. Déploiement des microservices
+1. Construction d'une image docker pour chaque microservice avec un simple fichier Dockerfile placé à la racine du dossier du microservice.
+2. Lancement avec un fichier **docke-compose** de la stack des microservices composant toute l'application backend.
+
+### Lancement de l'application backend
+1) Créer un répertoire que l'on nomme à son choix, **projet-microservices** par exemple.
+
+2) Cloner le git suivant de l'application dans ce répertoire:
+- Dans le terminal, se placer dans ce répetoire.
+- Saisir`git clone`: https://gitea.natan.fr/placidenduwayo/projects-management-microservices-backend.git
+
+Les microservices métiers, les microservices intermédiaires et application-deployment (le répertoire pour déployer l'application) sont téléchargés dans ce répertoire **projet-microservices**.
+
+Il faut avoir les application Docker et Docker-compose installées  sur la machine. Docker pour créer les images docker des microservices et docker-compose pour agencer et lancer en une seule ligne de commandes les images de toute l'application.
+
+Pour en savoir sur docker et docker-compose, voir les liens ![docker](https://docs.docker.com/get-started/) et [docker-compose](https://docs.docker.com/compose/)
+
+ 3) Dans le terminal:
+  - Se placer dans le sous-répertoire **application-deployment** du répertoire **projet-microservice**.
+  - Le fichier **docker-compose** sous ce répertoire application-deployment agence les images à créer via leurs Dockerfiles
+  - Saisir la ligne de commandes :`docker-compose build`:
+     - `docker-compose build` builde les sources de chaque microservice
+     - Ensuite, à partir du Dockerfile de chaque microservice, il créera des images docker pour les microservices
+
+Après le build de l'application backend:
+- Toujours dans le répertoire des microservices
+- Saisir la ligne de commande: `docker-compose up`. Cette ligne de commande va lancer toutes les images agencées dans le fichier docker-compose
+
+### 1.5. Services intermédiaires
+Les services **eureka-discovery-server** et **spring-cloud-gateway-service** sont de simples applications.
+- Le service spring-cloud-gateway-service n'expose aucun Endpoint.
+- Le service eureka-discovery-server expose un seul endepoint http://localhost:8180 pour explorer les microservices enregistrés
+
+### 1.5.1. eureka-discovery-server
+Ce service joue le rôle de serveur d'annuaire des microservices. eureka-discovery-server est lancé en premier. Lorsqu'ils sont lancés, les microservices métiers et le service gateway s'enregistrent dans le serveur d'annuaire. Ils s'enregistrent par leur nom configuré dans leur fichier de configuration **application.properties**.
+
+Le lien suivant présente la documentation de ce service d'annuaire [eureka service registration](https://spring.io/guides/gs/service-registration-and-discovery/).
+
+### 1.5.2. spring-cloud-gateway
+
+- Le service gateway **spring-cloud-gateway-service** peut être lancé avant ou après les microservices métiers. Ce service sert de gateway entre le frontend et le serveur d'annuaire qui contient les noms des microservices métiers.
+- Dans la requête HTTP, le client a juste besoin de connaître l'adresse de la gateway et le nom du microservice qu'il veut consommer. Sa requête est de la forme: **http://gateway-address:gateway-port/NOM-MICROSERVICE/endpoint**.
+- Le service gateway va chercher dans le serveur d'annuaire (ici nous avons utilisé Eureka de Netflix) le nom du microservice que le client HTTP a spécifié dans sa requête.
+- Si la gateway trouve le service demandé, le client peut commencer à consommer le microservice.
+
+
+# 2. Partie frontend: application Angular
+Le côté frontend est une application Angular (Angular 13). Le repository de cette application frontend peut être trouvé sur le lien suivant: [frontend](https://gitea.natan.fr/placidenduwayo/projects-management-microservices-frontend.git)
+
+Pour communiquer avec la partie backend, dans le fichier `environment.ts` d'Angular nous y configurons l'adresse du service gateway avec les noms des microservices pour la backend:
+
+```
+export const environment = {
+  ADDRESSES_SERVER:"http://localhost:8181/ADDRESS-MICROSERVICE",
+  USERS_SERVER:"http://localhost:8181/USER-MICROSERVICE",
+  COMPANIES_SERVER:"http://localhost:8181/COMPANY-MICROSERVICE",
+  PROJECTS_SERVER:"http://localhost:8181/PROJECT-MICROSERVICE"
+
+};
+```
+
+# 3. Lancement de l'application fullstack:
+## 3.1. La partie backend
+- Cloner la partie backend: `git clone` https://gitea.natan.fr/placidenduwayo/projects-management-microservices-backend.git
+- Lancer l'application backend en suivant la procédure décrite au sous titre **1.4 Déploiement des microservices**. 
+## 3.2. La partie frontend
+- cloner la partie frontend: `git clone` https://gitea.natan.fr/placidenduwayo/projects-management-microservices-frontend.git
+- Suivre la procédure telle que détaillée dans le README du repository
+- Aller sur http://localhost:4200 
+    - ![application front](https://drive.google.com/file/d/1CfXun5Sov_q5f045fJGCv0lk2XUq7_DN/view?usp=sharing) 

address-microservice/src/main/java/fr/natan/microservices/addressmicroservice/service/contract/AddressContract.java

@@ -1,19 +0,0 @@
-package fr.natan.microservices.addressmicroservice.service.contract;
-
-import fr.natan.microservices.addressmicroservice.exceptions.AddressAlreadyExistsException;
-import fr.natan.microservices.addressmicroservice.exceptions.AddressFieldsEmptyException;
-import fr.natan.microservices.addressmicroservice.exceptions.AddressNotFoundException;
-import fr.natan.microservices.addressmicroservice.model.Address;
-
-import java.util.List;
-
-public interface AddressContract {
-
-    Address createAddress (Address address) throws AddressAlreadyExistsException, AddressFieldsEmptyException;
-    List<Address> getAddresses();
-    List<Address> getAddressByNumHouseStreetNamePBCity(
-            String numHouse, String streetName, String pb, String city);
-    Address getAddress(Long addressID) throws AddressNotFoundException;
-    void deleteAddress(Long addressID) throws AddressNotFoundException;
-    Address updateAddress(Long addressID, Address address) throws AddressNotFoundException;
-}

address-microservice/src/main/java/fr/natan/microservices/addressmicroservice/service/services/AddressService.java

@@ -4,76 +4,16 @@ import fr.natan.microservices.addressmicroservice.exceptions.AddressAlreadyExist
 import fr.natan.microservices.addressmicroservice.exceptions.AddressFieldsEmptyException;
 import fr.natan.microservices.addressmicroservice.exceptions.AddressNotFoundException;
 import fr.natan.microservices.addressmicroservice.model.Address;
-import fr.natan.microservices.addressmicroservice.repository.AddressRepository;
-import fr.natan.microservices.addressmicroservice.service.contract.AddressContract;
-import fr.natan.microservices.addressmicroservice.service.utilities.AddressValidator;
-import org.springframework.stereotype.Service;
 
-import javax.transaction.Transactional;
 import java.util.List;
 
-@Service
-public class AddressService implements AddressContract {
-    private final AddressRepository addressRepository;
+public interface AddressService {
 
-    public AddressService(AddressRepository addressRepository) {
-        this.addressRepository = addressRepository;
-    }
-
-
-    @Override
-    public List<Address> getAddressByNumHouseStreetNamePBCity(String numHouse, String streetName, String pb, String city) {
-
-        return addressRepository.findByNumHouseAndStreetNameAndPbAndCity(numHouse,
-                streetName, pb, city);
-    }
-
-    @Override
-    public Address createAddress(Address address) throws AddressAlreadyExistsException, AddressFieldsEmptyException {
-        if(!AddressValidator.isValidAddress(address)){
-            throw new AddressFieldsEmptyException();
-        }
-
-        Address formattedAddress = AddressValidator.formatAddress(address);
-        if (getAddressByNumHouseStreetNamePBCity(
-                formattedAddress.getNumHouse(),
-                formattedAddress.getStreetName(),
-                formattedAddress.getPb(),
-                formattedAddress.getCity() ).size() > 0) {
-
-            throw new AddressAlreadyExistsException();
-        }
-
-        return addressRepository.save(formattedAddress);
-    }
-
-    @Override
-    public List<Address> getAddresses() {
-        return addressRepository.findAll();
-    }
-
-    @Override
-    public Address getAddress(Long addressID) throws AddressNotFoundException {
-        return addressRepository.findById(addressID).orElseThrow(
-                AddressNotFoundException::new
-        );
-    }
-
-    @Override
-    public void deleteAddress(Long addressID) throws AddressNotFoundException {
-        addressRepository.delete(getAddress(addressID));
-    }
-
-    @Override
-    @Transactional
-    public Address updateAddress(Long addressID, Address address) throws AddressNotFoundException {
-        Address savedAddress = getAddress(addressID);
-        savedAddress.setNumHouse(address.getNumHouse());
-        savedAddress.setStreetName(address.getStreetName());
-        savedAddress.setPb(address.getPb());
-        savedAddress.setCity(address.getCity());
-        savedAddress.setCountry(address.getCountry());
-
-        return savedAddress;
-    }
+    Address createAddress (Address address) throws AddressAlreadyExistsException, AddressFieldsEmptyException;
+    List<Address> getAddresses();
+    List<Address> getAddressByNumHouseStreetNamePBCity(
+            String numHouse, String streetName, String pb, String city);
+    Address getAddress(Long addressID) throws AddressNotFoundException;
+    void deleteAddress(Long addressID) throws AddressNotFoundException;
+    Address updateAddress(Long addressID, Address address) throws AddressNotFoundException;
 }

address-microservice/src/main/java/fr/natan/microservices/addressmicroservice/service/services/AddressServiceImplement.java

@@ -0,0 +1,78 @@
+package fr.natan.microservices.addressmicroservice.service.services;
+
+import fr.natan.microservices.addressmicroservice.exceptions.AddressAlreadyExistsException;
+import fr.natan.microservices.addressmicroservice.exceptions.AddressFieldsEmptyException;
+import fr.natan.microservices.addressmicroservice.exceptions.AddressNotFoundException;
+import fr.natan.microservices.addressmicroservice.model.Address;
+import fr.natan.microservices.addressmicroservice.repository.AddressRepository;
+import fr.natan.microservices.addressmicroservice.service.utilities.AddressValidator;
+import org.springframework.stereotype.Service;
+
+import javax.transaction.Transactional;
+import java.util.List;
+
+@Service
+public class AddressServiceImplement implements AddressService {
+    private final AddressRepository addressRepository;
+
+    public AddressServiceImplement(AddressRepository addressRepository) {
+        this.addressRepository = addressRepository;
+    }
+
+
+    @Override
+    public List<Address> getAddressByNumHouseStreetNamePBCity(String numHouse, String streetName, String pb, String city) {
+
+        return addressRepository.findByNumHouseAndStreetNameAndPbAndCity(numHouse,
+                streetName, pb, city);
+    }
+
+    @Override
+    public Address createAddress(Address address) throws AddressAlreadyExistsException, AddressFieldsEmptyException {
+        if(!AddressValidator.isValidAddress(address)){
+            throw new AddressFieldsEmptyException();
+        }
+
+        Address formattedAddress = AddressValidator.formatAddress(address);
+        if (getAddressByNumHouseStreetNamePBCity(
+                formattedAddress.getNumHouse(),
+                formattedAddress.getStreetName(),
+                formattedAddress.getPb(),
+                formattedAddress.getCity() ).size() > 0) {
+
+            throw new AddressAlreadyExistsException();
+        }
+
+        return addressRepository.save(formattedAddress);
+    }
+
+    @Override
+    public List<Address> getAddresses() {
+        return addressRepository.findAll();
+    }
+
+    @Override
+    public Address getAddress(Long addressID) throws AddressNotFoundException {
+        return addressRepository.findById(addressID).orElseThrow(
+                AddressNotFoundException::new
+        );
+    }
+
+    @Override
+    public void deleteAddress(Long addressID) throws AddressNotFoundException {
+        addressRepository.delete(getAddress(addressID));
+    }
+
+    @Override
+    @Transactional
+    public Address updateAddress(Long addressID, Address address) throws AddressNotFoundException {
+        Address savedAddress = getAddress(addressID);
+        savedAddress.setNumHouse(address.getNumHouse());
+        savedAddress.setStreetName(address.getStreetName());
+        savedAddress.setPb(address.getPb());
+        savedAddress.setCity(address.getCity());
+        savedAddress.setCountry(address.getCountry());
+
+        return savedAddress;
+    }
+}

address-microservice/src/main/java/fr/natan/microservices/addressmicroservice/t_controller/AddressController.java

@@ -4,16 +4,16 @@ import fr.natan.microservices.addressmicroservice.exceptions.AddressAlreadyExist
 import fr.natan.microservices.addressmicroservice.exceptions.AddressFieldsEmptyException;
 import fr.natan.microservices.addressmicroservice.exceptions.AddressNotFoundException;
 import fr.natan.microservices.addressmicroservice.model.Address;
-import fr.natan.microservices.addressmicroservice.service.contract.AddressContract;
+import fr.natan.microservices.addressmicroservice.service.services.AddressService;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.List;
 
 @RestController
 public class AddressController {
-    private final AddressContract addressContract;
+    private final AddressService addressContract;
 
-    public AddressController(AddressContract addressContract) {
+    public AddressController(AddressService addressContract) {
         this.addressContract = addressContract;
     }
 

company-microservice/src/main/java/fr/natan/microservices/companymicroservice/service/contract/CompanyContract.java

@@ -1,19 +0,0 @@
-package fr.natan.microservices.companymicroservice.service.contract;
-
-import fr.natan.microservices.companymicroservice.exceptions.CompanyAlreadyExistsException;
-import fr.natan.microservices.companymicroservice.exceptions.CompanyFieldsEmptyException;
-import fr.natan.microservices.companymicroservice.exceptions.CompanyNotFoundException;
-import fr.natan.microservices.companymicroservice.exceptions.CompanyTypesInvalidException;
-import fr.natan.microservices.companymicroservice.model.company.Company;
-
-import java.util.Collection;
-import java.util.List;
-
-public interface CompanyContract {
-    Company createCompany(Company company) throws CompanyAlreadyExistsException, CompanyFieldsEmptyException, CompanyTypesInvalidException;
-    Collection<Company> getCompanies();
-    List<Company> getCompanyByName(String companyName);
-    Company getCompany(Long companyID) throws CompanyNotFoundException;
-    void deleteCompany(Long companyID) throws CompanyNotFoundException;
-    Company updateCompany(Long companyID, Company company) throws CompanyNotFoundException, CompanyFieldsEmptyException;
-}

company-microservice/src/main/java/fr/natan/microservices/companymicroservice/service/services/CompanyService.java

@@ -5,78 +5,15 @@ import fr.natan.microservices.companymicroservice.exceptions.CompanyFieldsEmptyE
 import fr.natan.microservices.companymicroservice.exceptions.CompanyNotFoundException;
 import fr.natan.microservices.companymicroservice.exceptions.CompanyTypesInvalidException;
 import fr.natan.microservices.companymicroservice.model.company.Company;
-import fr.natan.microservices.companymicroservice.repository.CompanyRepository;
-import fr.natan.microservices.companymicroservice.service.contract.CompanyContract;
-import fr.natan.microservices.companymicroservice.service.utilities.CompanyValidator;
-import org.springframework.stereotype.Service;
 
-import javax.transaction.Transactional;
-import java.sql.Date;
-import java.sql.Time;
 import java.util.Collection;
 import java.util.List;
 
-@Service
-public class CompanyService implements CompanyContract {
-
-    private final CompanyRepository companyRepository;
-
-    public CompanyService(CompanyRepository companyRepository) {
-        this.companyRepository = companyRepository;
-    }
-
-    @Override
-    public List<Company> getCompanyByName(String companyName) {
-        return companyRepository.findByCompanyName(companyName);
-    }
-    @Override
-    public Company createCompany(Company company) throws CompanyAlreadyExistsException, CompanyFieldsEmptyException,
-            CompanyTypesInvalidException {
-        if(! CompanyValidator.isValidCompany(company)){
-            throw new CompanyFieldsEmptyException();
-        }
-        else if(!CompanyValidator.validCompanyTypes(company)){
-            throw new CompanyTypesInvalidException();
-        }
-        Company formattedCompany = CompanyValidator.formatCompany(company);
-        if(getCompanyByName(formattedCompany.getCompanyName()).size()>0){
-            throw new CompanyAlreadyExistsException();
-        }
-
-        company.setConnectionDate(new Date(System.currentTimeMillis())+" : "+new Time(System.currentTimeMillis()));
-
-        return companyRepository.save(formattedCompany);
-    }
-
-    @Override
-    public Collection<Company> getCompanies() {
-        return companyRepository.findAll();
-    }
-
-    @Override
-    public Company getCompany(Long companyID) throws CompanyNotFoundException {
-        return companyRepository.findById(companyID).orElseThrow(
-                ()-> new CompanyNotFoundException()
-        );
-    }
-
-    @Override
-    public void deleteCompany(Long companyID) throws CompanyNotFoundException {
-        companyRepository.delete(getCompany(companyID));
-    }
-
-    @Override
-    @Transactional
-    public Company updateCompany(Long companyID, Company company) throws CompanyNotFoundException,
-            CompanyFieldsEmptyException {
-        if(!CompanyValidator.isValidCompany(company))
-            throw new CompanyFieldsEmptyException();
-
-       Company savedCompany = getCompany(companyID);
-       savedCompany.setCompanyName(company.getCompanyName());
-       savedCompany.setCompanyType1(company.getCompanyType1());
-       savedCompany.setCompanyType2(company.getCompanyType2());
-
-        return savedCompany;
-    }
+public interface CompanyService {
+    Company createCompany(Company company) throws CompanyAlreadyExistsException, CompanyFieldsEmptyException, CompanyTypesInvalidException;
+    Collection<Company> getCompanies();
+    List<Company> getCompanyByName(String companyName);
+    Company getCompany(Long companyID) throws CompanyNotFoundException;
+    void deleteCompany(Long companyID) throws CompanyNotFoundException;
+    Company updateCompany(Long companyID, Company company) throws CompanyNotFoundException, CompanyFieldsEmptyException;
 }

company-microservice/src/main/java/fr/natan/microservices/companymicroservice/service/services/CompanyServiceImplement.java

@@ -0,0 +1,81 @@
+package fr.natan.microservices.companymicroservice.service.services;
+
+import fr.natan.microservices.companymicroservice.exceptions.CompanyAlreadyExistsException;
+import fr.natan.microservices.companymicroservice.exceptions.CompanyFieldsEmptyException;
+import fr.natan.microservices.companymicroservice.exceptions.CompanyNotFoundException;
+import fr.natan.microservices.companymicroservice.exceptions.CompanyTypesInvalidException;
+import fr.natan.microservices.companymicroservice.model.company.Company;
+import fr.natan.microservices.companymicroservice.repository.CompanyRepository;
+import fr.natan.microservices.companymicroservice.service.utilities.CompanyValidator;
+import org.springframework.stereotype.Service;
+
+import javax.transaction.Transactional;
+import java.sql.Date;
+import java.sql.Time;
+import java.util.Collection;
+import java.util.List;
+
+@Service
+public class CompanyServiceImplement implements CompanyService {
+
+    private final CompanyRepository companyRepository;
+
+    public CompanyServiceImplement(CompanyRepository companyRepository) {
+        this.companyRepository = companyRepository;
+    }
+
+    @Override
+    public List<Company> getCompanyByName(String companyName) {
+        return companyRepository.findByCompanyName(companyName);
+    }
+    @Override
+    public Company createCompany(Company company) throws CompanyAlreadyExistsException, CompanyFieldsEmptyException,
+            CompanyTypesInvalidException {
+        if(! CompanyValidator.isValidCompany(company)){
+            throw new CompanyFieldsEmptyException();
+        }
+        else if(!CompanyValidator.validCompanyTypes(company)){
+            throw new CompanyTypesInvalidException();
+        }
+        Company formattedCompany = CompanyValidator.formatCompany(company);
+        if(getCompanyByName(formattedCompany.getCompanyName()).size()>0){
+            throw new CompanyAlreadyExistsException();
+        }
+
+        company.setConnectionDate(new Date(System.currentTimeMillis())+" : "+new Time(System.currentTimeMillis()));
+
+        return companyRepository.save(formattedCompany);
+    }
+
+    @Override
+    public Collection<Company> getCompanies() {
+        return companyRepository.findAll();
+    }
+
+    @Override
+    public Company getCompany(Long companyID) throws CompanyNotFoundException {
+        return companyRepository.findById(companyID).orElseThrow(
+                ()-> new CompanyNotFoundException()
+        );
+    }
+
+    @Override
+    public void deleteCompany(Long companyID) throws CompanyNotFoundException {
+        companyRepository.delete(getCompany(companyID));
+    }
+
+    @Override
+    @Transactional
+    public Company updateCompany(Long companyID, Company company) throws CompanyNotFoundException,
+            CompanyFieldsEmptyException {
+        if(!CompanyValidator.isValidCompany(company))
+            throw new CompanyFieldsEmptyException();
+
+       Company savedCompany = getCompany(companyID);
+       savedCompany.setCompanyName(company.getCompanyName());
+       savedCompany.setCompanyType1(company.getCompanyType1());
+       savedCompany.setCompanyType2(company.getCompanyType2());
+
+        return savedCompany;
+    }
+}

company-microservice/src/main/java/fr/natan/microservices/companymicroservice/t_controller/CompanyController.java

@@ -5,7 +5,7 @@ import fr.natan.microservices.companymicroservice.exceptions.CompanyFieldsEmptyE
 import fr.natan.microservices.companymicroservice.exceptions.CompanyNotFoundException;
 import fr.natan.microservices.companymicroservice.exceptions.CompanyTypesInvalidException;
 import fr.natan.microservices.companymicroservice.model.company.Company;
-import fr.natan.microservices.companymicroservice.service.contract.CompanyContract;
+import fr.natan.microservices.companymicroservice.service.services.CompanyService;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.Collection;
@@ -13,9 +13,9 @@ import java.util.Collection;
 @RestController
 public class CompanyController {
 
-    private final CompanyContract companyContract;
+    private final CompanyService companyContract;
 
-    public CompanyController(CompanyContract companyContract) {
+    public CompanyController(CompanyService companyContract) {
         this.companyContract = companyContract;
     }
 

project-microservice/src/main/java/fr/natan/microservices/projectmicroservice/service/contract/ProjectContract.java

@@ -1,23 +0,0 @@
-package fr.natan.microservices.projectmicroservice.service.contract;
-
-import fr.natan.microservices.projectmicroservice.model.entity.Project;
-import fr.natan.microservices.projectmicroservice.module_exception.exceptions.*;
-
-import java.util.Collection;
-
-public interface ProjectContract {
-    Collection<Project> getProjects(String projectName);
-    Project createProject(Project project) throws ProjectAlreadyExistsException,
-            ProjectFieldsEmptyException, ProjectDescriptionShortException, UserNotFoundException,
-            AddressNotFoundException, CompanyNotFoundException, ProjectPriorityInvalidException, ProjectStateInvalidException;
-    Collection<Project> getProjects();
-    Project getProject(Long projectID) throws ProjectNotFoundException, CompanyNotFoundException, UserNotFoundException;
-    Collection<Project> getProjectForUser(Long userID) throws UserNotFoundException;
-    Collection<Project> getProjectForCompany(Long companyID) throws CompanyNotFoundException;
-    Collection<Project> getProjectForUserInCompany(Long userID, Long companyID) throws UserNotFoundException,
-    CompanyNotFoundException;
-
-    Project updateProject(Long projectID, Project project) throws ProjectNotFoundException,
-            ProjectFieldsEmptyException, ProjectDescriptionShortException, UserNotFoundException, CompanyNotFoundException;
-    void deleteProject(Long projectID) throws ProjectNotFoundException, UserNotFoundException, CompanyNotFoundException;
-}

project-microservice/src/main/java/fr/natan/microservices/projectmicroservice/service/services/ProjectService.java

@@ -2,196 +2,22 @@ package fr.natan.microservices.projectmicroservice.service.services;
 
 import fr.natan.microservices.projectmicroservice.model.entity.Project;
 import fr.natan.microservices.projectmicroservice.module_exception.exceptions.*;
-import fr.natan.microservices.projectmicroservice.repository.ProjectRepository;
-import fr.natan.microservices.projectmicroservice.service.contract.ProjectContract;
-import fr.natan.microservices.projectmicroservice.service.utilities.ProjectValidator;
-import fr.natan.microservices.projectmicroservice.t_openfeign.models.address.Address;
-import fr.natan.microservices.projectmicroservice.t_openfeign.models.company.entity.Company;
-import fr.natan.microservices.projectmicroservice.t_openfeign.models.user.User;
-import fr.natan.microservices.projectmicroservice.t_openfeign.services.AddressService;
-import fr.natan.microservices.projectmicroservice.t_openfeign.services.CompanyService;
-import fr.natan.microservices.projectmicroservice.t_openfeign.services.UserService;
-import org.springframework.stereotype.Service;
 
-import javax.transaction.Transactional;
-import java.sql.Date;
-import java.sql.Time;
 import java.util.Collection;
 
-@Service
-public class ProjectService implements ProjectContract {
-    private final ProjectRepository projectRepository;
-    private  final AddressService addressService;
-    private final UserService userService;
-    private final CompanyService companyService;
-
-    public ProjectService(ProjectRepository projectRepository,
-                          AddressService addressService, UserService userService,
-                          CompanyService companyService) {
-        this.projectRepository = projectRepository;
-        this.addressService = addressService;
-        this.userService = userService;
-        this.companyService = companyService;
-    }
-
-    @Override
-    public Collection<Project> getProjects(String projectName) {
-        return projectRepository.findByProjectName(projectName);
-    }
-
-    @Override
-    public Project createProject(Project project) throws ProjectAlreadyExistsException, ProjectFieldsEmptyException,
-            ProjectDescriptionShortException, UserNotFoundException, AddressNotFoundException,
-            CompanyNotFoundException, ProjectPriorityInvalidException, ProjectStateInvalidException {
-        //check fields
-        if(!ProjectValidator.areValidProjectFields(project)){
-            throw new ProjectFieldsEmptyException();
-        }
-        //check size of description
-        else if(! ProjectValidator.isValidProjectDescription(project)){
-            throw new ProjectDescriptionShortException();
-        }
-
-        //check if input priority is in the enum
-        if(!ProjectValidator.isValidProjectPriority(project)){
-            throw new ProjectPriorityInvalidException();
-        }
-
-        if(!ProjectValidator.isValidProjectState(project)){
-            throw new ProjectStateInvalidException();
-        }
-        if(getProjects(project.getProjectName()).size()>0){
-            throw new ProjectAlreadyExistsException();
-        }
-
-        Project formattedProject = ProjectValidator.formatProject(project);
-        User user = userService.getUserByID(project.getUserID());
-        Address address = addressService.getAddressByID(user.getAddressID());
-        user.setAddress(address);
-
-        formattedProject.setCreatedDate(
-                new Date(System.currentTimeMillis())+" : "
-                        + new Time(System.currentTimeMillis())
-        );
-
-        formattedProject.setUser(user);
-
-        Company company = companyService.getCompanyByID(project.getCompanyID());
-        formattedProject.setCompany(company);
-
-        return projectRepository.save(formattedProject);
-    }
-
-    @Override
-    public Collection<Project> getProjects() {
-        Collection<Project> projects = projectRepository.findAll();
-        projects.forEach(project -> {
-            try {
-                project.setUser(userService.getUserByID(project.getUserID()));
-                project.setCompany(companyService.getCompanyByID(project.getCompanyID()));
-            } catch (UserNotFoundException | CompanyNotFoundException e) {
-                e.printStackTrace();
-            }
-        });
-
-        return projects;
-    }
-
-    @Override
-    public Project getProject(Long projectID) throws ProjectNotFoundException, CompanyNotFoundException, UserNotFoundException {
-        Project project = projectRepository.findById(projectID).orElseThrow(
-                ()-> new ProjectNotFoundException()
-        );
-        project.setCompany(companyService.getCompanyByID(project.getCompanyID()));
-        project.setUser(userService.getUserByID(project.getUserID()));
-        return project;
-    }
-
-    @Override
-    public Collection<Project> getProjectForUser(Long userID) throws UserNotFoundException {
-        if(userService.getUserByID(userID)== null){
-            throw new UserNotFoundException();
-        }
-        Collection<Project> projects = projectRepository.findByUserID(userID);
-
-        projects.forEach(project -> {
-            try {
-                project.setUser(userService.getUserByID(project.getUserID()));
-                project.setCompany(companyService.getCompanyByID(project.getCompanyID()));
-            } catch (UserNotFoundException | CompanyNotFoundException e) {
-                e.printStackTrace();
-            }
-        });
-        return projects;
-    }
-
-    @Override
-    public Collection<Project> getProjectForCompany(Long companyID) throws CompanyNotFoundException {
-        if(companyService.getCompanyByID(companyID)==null){
-            throw new CompanyNotFoundException();
-        }
-        Collection<Project> projects = projectRepository.findByCompanyID(companyID);
-        projects.forEach(project -> {
-            try {
-                project.setUser(userService.getUserByID(project.getUserID()));
-                project.setCompany(companyService.getCompanyByID(project.getCompanyID()));
-            } catch (UserNotFoundException | CompanyNotFoundException e) {
-                e.printStackTrace();
-            }
-        });
-        return projects;
-    }
-
-    @Override
-    public Collection<Project> getProjectForUserInCompany(Long userID, Long companyID) throws
-            UserNotFoundException, CompanyNotFoundException {
-        if(userService.getUserByID(userID)==null){
-            throw new UserNotFoundException();
-        }
-        if(companyService.getCompanyByID(companyID)==null){
-            throw new CompanyNotFoundException();
-        }
-        Collection<Project> projects = projectRepository.findByUserIDAndCompanyID(userID, companyID);
-        projects.forEach(project -> {
-            try {
-                project.setUser(userService.getUserByID(userID));
-                project.setCompany(companyService.getCompanyByID(companyID));
-            } catch (UserNotFoundException | CompanyNotFoundException e) {
-                throw new RuntimeException(e);
-            }
-        });
-
-        return projects;
-    }
-
-    @Override
-    @Transactional
-    public Project updateProject(Long projectID, Project project) throws ProjectNotFoundException,
-            ProjectFieldsEmptyException, ProjectDescriptionShortException, UserNotFoundException, CompanyNotFoundException {
-
-        if(!ProjectValidator.areValidProjectFields(project)){
-            throw new ProjectFieldsEmptyException();
-        }
-        else if(!ProjectValidator.isValidProjectDescription(project)){
-            throw new ProjectDescriptionShortException();
-        }
-        Project formattedProject = ProjectValidator.formatProject(project);
-        Project savedProject = getProject(projectID);
-
-        savedProject.setProjectName(formattedProject.getProjectName());
-        savedProject.setPriority(formattedProject.getPriority());
-        savedProject.setDescription(project.getDescription());
-        savedProject.setUserID(project.getUserID());
-        savedProject.setUser(userService.getUserByID(project.getUserID()));
-        savedProject.setCompanyID(project.getCompanyID());
-        savedProject.setCompany(companyService.getCompanyByID(project.getCompanyID()));
-        savedProject.setProjState(project.getProjState());
-
-        return savedProject;
-    }
-
-    @Override
-    public void deleteProject(Long projectID) throws ProjectNotFoundException, UserNotFoundException, CompanyNotFoundException {
-        projectRepository.delete(getProject(projectID));
-    }
+public interface ProjectService {
+    Collection<Project> getProjects(String projectName);
+    Project createProject(Project project) throws ProjectAlreadyExistsException,
+            ProjectFieldsEmptyException, ProjectDescriptionShortException, UserNotFoundException,
+            AddressNotFoundException, CompanyNotFoundException, ProjectPriorityInvalidException, ProjectStateInvalidException;
+    Collection<Project> getProjects();
+    Project getProject(Long projectID) throws ProjectNotFoundException, CompanyNotFoundException, UserNotFoundException;
+    Collection<Project> getProjectForUser(Long userID) throws UserNotFoundException;
+    Collection<Project> getProjectForCompany(Long companyID) throws CompanyNotFoundException;
+    Collection<Project> getProjectForUserInCompany(Long userID, Long companyID) throws UserNotFoundException,
+    CompanyNotFoundException;
+
+    Project updateProject(Long projectID, Project project) throws ProjectNotFoundException,
+            ProjectFieldsEmptyException, ProjectDescriptionShortException, UserNotFoundException, CompanyNotFoundException;
+    void deleteProject(Long projectID) throws ProjectNotFoundException, UserNotFoundException, CompanyNotFoundException;
 }

project-microservice/src/main/java/fr/natan/microservices/projectmicroservice/service/services/ProjectServiceImplement.java

@@ -0,0 +1,196 @@
+package fr.natan.microservices.projectmicroservice.service.services;
+
+import fr.natan.microservices.projectmicroservice.model.entity.Project;
+import fr.natan.microservices.projectmicroservice.module_exception.exceptions.*;
+import fr.natan.microservices.projectmicroservice.repository.ProjectRepository;
+import fr.natan.microservices.projectmicroservice.service.utilities.ProjectValidator;
+import fr.natan.microservices.projectmicroservice.t_openfeign.models.address.Address;
+import fr.natan.microservices.projectmicroservice.t_openfeign.models.company.entity.Company;
+import fr.natan.microservices.projectmicroservice.t_openfeign.models.user.User;
+import fr.natan.microservices.projectmicroservice.t_openfeign.services.AddressService;
+import fr.natan.microservices.projectmicroservice.t_openfeign.services.CompanyService;
+import fr.natan.microservices.projectmicroservice.t_openfeign.services.UserService;
+import org.springframework.stereotype.Service;
+
+import javax.transaction.Transactional;
+import java.sql.Date;
+import java.sql.Time;
+import java.util.Collection;
+
+@Service
+public class ProjectServiceImplement implements ProjectService {
+    private final ProjectRepository projectRepository;
+    private  final AddressService addressService;
+    private final UserService userService;
+    private final CompanyService companyService;
+
+    public ProjectServiceImplement(ProjectRepository projectRepository,
+                                   AddressService addressService, UserService userService,
+                                   CompanyService companyService) {
+        this.projectRepository = projectRepository;
+        this.addressService = addressService;
+        this.userService = userService;
+        this.companyService = companyService;
+    }
+
+    @Override
+    public Collection<Project> getProjects(String projectName) {
+        return projectRepository.findByProjectName(projectName);
+    }
+
+    @Override
+    public Project createProject(Project project) throws ProjectAlreadyExistsException, ProjectFieldsEmptyException,
+            ProjectDescriptionShortException, UserNotFoundException, AddressNotFoundException,
+            CompanyNotFoundException, ProjectPriorityInvalidException, ProjectStateInvalidException {
+        //check fields
+        if(!ProjectValidator.areValidProjectFields(project)){
+            throw new ProjectFieldsEmptyException();
+        }
+        //check size of description
+        else if(! ProjectValidator.isValidProjectDescription(project)){
+            throw new ProjectDescriptionShortException();
+        }
+
+        //check if input priority is in the enum
+        if(!ProjectValidator.isValidProjectPriority(project)){
+            throw new ProjectPriorityInvalidException();
+        }
+
+        if(!ProjectValidator.isValidProjectState(project)){
+            throw new ProjectStateInvalidException();
+        }
+        if(getProjects(project.getProjectName()).size()>0){
+            throw new ProjectAlreadyExistsException();
+        }
+
+        Project formattedProject = ProjectValidator.formatProject(project);
+        User user = userService.getUserByID(project.getUserID());
+        Address address = addressService.getAddressByID(user.getAddressID());
+        user.setAddress(address);
+
+        formattedProject.setCreatedDate(
+                new Date(System.currentTimeMillis())+" : "
+                        + new Time(System.currentTimeMillis())
+        );
+
+        formattedProject.setUser(user);
+
+        Company company = companyService.getCompanyByID(project.getCompanyID());
+        formattedProject.setCompany(company);
+
+        return projectRepository.save(formattedProject);
+    }
+
+    @Override
+    public Collection<Project> getProjects() {
+        Collection<Project> projects = projectRepository.findAll();
+        projects.forEach(project -> {
+            try {
+                project.setUser(userService.getUserByID(project.getUserID()));
+                project.setCompany(companyService.getCompanyByID(project.getCompanyID()));
+            } catch (UserNotFoundException | CompanyNotFoundException e) {
+                e.printStackTrace();
+            }
+        });
+
+        return projects;
+    }
+
+    @Override
+    public Project getProject(Long projectID) throws ProjectNotFoundException, CompanyNotFoundException, UserNotFoundException {
+        Project project = projectRepository.findById(projectID).orElseThrow(
+                ()-> new ProjectNotFoundException()
+        );
+        project.setCompany(companyService.getCompanyByID(project.getCompanyID()));
+        project.setUser(userService.getUserByID(project.getUserID()));
+        return project;
+    }
+
+    @Override
+    public Collection<Project> getProjectForUser(Long userID) throws UserNotFoundException {
+        if(userService.getUserByID(userID)== null){
+            throw new UserNotFoundException();
+        }
+        Collection<Project> projects = projectRepository.findByUserID(userID);
+
+        projects.forEach(project -> {
+            try {
+                project.setUser(userService.getUserByID(project.getUserID()));
+                project.setCompany(companyService.getCompanyByID(project.getCompanyID()));
+            } catch (UserNotFoundException | CompanyNotFoundException e) {
+                e.printStackTrace();
+            }
+        });
+        return projects;
+    }
+
+    @Override
+    public Collection<Project> getProjectForCompany(Long companyID) throws CompanyNotFoundException {
+        if(companyService.getCompanyByID(companyID)==null){
+            throw new CompanyNotFoundException();
+        }
+        Collection<Project> projects = projectRepository.findByCompanyID(companyID);
+        projects.forEach(project -> {
+            try {
+                project.setUser(userService.getUserByID(project.getUserID()));
+                project.setCompany(companyService.getCompanyByID(project.getCompanyID()));
+            } catch (UserNotFoundException | CompanyNotFoundException e) {
+                e.printStackTrace();
+            }
+        });
+        return projects;
+    }
+
+    @Override
+    public Collection<Project> getProjectForUserInCompany(Long userID, Long companyID) throws
+            UserNotFoundException, CompanyNotFoundException {
+        if(userService.getUserByID(userID)==null){
+            throw new UserNotFoundException();
+        }
+        if(companyService.getCompanyByID(companyID)==null){
+            throw new CompanyNotFoundException();
+        }
+        Collection<Project> projects = projectRepository.findByUserIDAndCompanyID(userID, companyID);
+        projects.forEach(project -> {
+            try {
+                project.setUser(userService.getUserByID(userID));
+                project.setCompany(companyService.getCompanyByID(companyID));
+            } catch (UserNotFoundException | CompanyNotFoundException e) {
+                throw new RuntimeException(e);
+            }
+        });
+
+        return projects;
+    }
+
+    @Override
+    @Transactional
+    public Project updateProject(Long projectID, Project project) throws ProjectNotFoundException,
+            ProjectFieldsEmptyException, ProjectDescriptionShortException, UserNotFoundException, CompanyNotFoundException {
+
+        if(!ProjectValidator.areValidProjectFields(project)){
+            throw new ProjectFieldsEmptyException();
+        }
+        else if(!ProjectValidator.isValidProjectDescription(project)){
+            throw new ProjectDescriptionShortException();
+        }
+        Project formattedProject = ProjectValidator.formatProject(project);
+        Project savedProject = getProject(projectID);
+
+        savedProject.setProjectName(formattedProject.getProjectName());
+        savedProject.setPriority(formattedProject.getPriority());
+        savedProject.setDescription(project.getDescription());
+        savedProject.setUserID(project.getUserID());
+        savedProject.setUser(userService.getUserByID(project.getUserID()));
+        savedProject.setCompanyID(project.getCompanyID());
+        savedProject.setCompany(companyService.getCompanyByID(project.getCompanyID()));
+        savedProject.setProjState(project.getProjState());
+
+        return savedProject;
+    }
+
+    @Override
+    public void deleteProject(Long projectID) throws ProjectNotFoundException, UserNotFoundException, CompanyNotFoundException {
+        projectRepository.delete(getProject(projectID));
+    }
+}

project-microservice/src/main/java/fr/natan/microservices/projectmicroservice/tt_controller/ProjectController.java

@@ -2,7 +2,7 @@ package fr.natan.microservices.projectmicroservice.tt_controller;
 
 import fr.natan.microservices.projectmicroservice.model.entity.Project;
 import fr.natan.microservices.projectmicroservice.module_exception.exceptions.*;
-import fr.natan.microservices.projectmicroservice.service.contract.ProjectContract;
+import fr.natan.microservices.projectmicroservice.service.services.ProjectService;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.Collection;
@@ -10,9 +10,9 @@ import java.util.Collection;
 @RestController
 public class ProjectController {
 
-    private final ProjectContract projectContract;
+    private final ProjectService projectContract;
 
-    public ProjectController(ProjectContract projectContract) {
+    public ProjectController(ProjectService projectContract) {
         this.projectContract = projectContract;
     }
 

user-microservice/src/main/java/fr/natan/microservices/usermicroservice/service/contract/UserContract.java

@@ -1,20 +0,0 @@
-package fr.natan.microservices.usermicroservice.service.contract;
-
-import fr.natan.microservices.usermicroservice.exceptions.AddressNotFoundException;
-import fr.natan.microservices.usermicroservice.exceptions.UserAlreadyExistsException;
-import fr.natan.microservices.usermicroservice.exceptions.UserFieldsEmptyException;
-import fr.natan.microservices.usermicroservice.exceptions.UserNotFoundException;
-import fr.natan.microservices.usermicroservice.model.User;
-
-import java.util.Collection;
-
-public interface UserContract {
-    User createUser(User user) throws UserAlreadyExistsException, UserFieldsEmptyException, AddressNotFoundException;
-    Collection<User> getUsers();
-    Collection<User> getUsers(String firstname, String lastname);
-    User getUser(Long userID) throws UserNotFoundException, AddressNotFoundException;
-    User updateUser(Long userID, User user) throws UserNotFoundException, UserFieldsEmptyException, AddressNotFoundException;
-    void deleteUser(Long userID) throws UserNotFoundException, AddressNotFoundException;
-    void deleteAllUsers();
-    Collection<User> getUsersLivingAtAddress(Long addressID) throws AddressNotFoundException;
-}

user-microservice/src/main/java/fr/natan/microservices/usermicroservice/service/services/UserService.java

@@ -5,131 +5,16 @@ import fr.natan.microservices.usermicroservice.exceptions.UserAlreadyExistsExcep
 import fr.natan.microservices.usermicroservice.exceptions.UserFieldsEmptyException;
 import fr.natan.microservices.usermicroservice.exceptions.UserNotFoundException;
 import fr.natan.microservices.usermicroservice.model.User;
-import fr.natan.microservices.usermicroservice.repository.UserRepository;
-import fr.natan.microservices.usermicroservice.service.contract.UserContract;
-import fr.natan.microservices.usermicroservice.service.utilities.UserValidator;
-import fr.natan.microservices.usermicroservice.t_openfeign.model.Address;
-import fr.natan.microservices.usermicroservice.t_openfeign.service.AddressService;
-import org.springframework.stereotype.Service;
 
-import javax.transaction.Transactional;
-import java.sql.Date;
-import java.sql.Time;
 import java.util.Collection;
 
-@Service
-public class UserService implements UserContract {
-
-    private final UserRepository userRepository;
-    private final AddressService addressService;
-
-    public UserService(UserRepository userRepository, AddressService addressService) {
-        this.userRepository = userRepository;
-        this.addressService = addressService;
-    }
-
-    @Override
-    public Collection<User> getUsers(String firstname, String lastname) {
-        return userRepository.findByFirstnameAndLastname(firstname, lastname);
-    }
-
-    @Override
-    public User createUser(User user) throws UserAlreadyExistsException, UserFieldsEmptyException, AddressNotFoundException {
-        if(!UserValidator.isValidUser(user)){
-            throw new UserFieldsEmptyException();
-        }
-        User formattedUser = UserValidator.formatUser(user);
-        if(getUsers(formattedUser.getFirstname(), formattedUser.getLastname()).size()>0){
-            throw new UserAlreadyExistsException();
-        }
-
-        user.setCreatedDate(new Date(System.currentTimeMillis()) + " : " + new Time(System.currentTimeMillis()));
-
-
-        Address address = addressService.getAddress(user.getAddressID());
-        if(address==null){
-            throw new AddressNotFoundException();
-        }
-        user.setAddressID(user.getAddressID());
-        user.setAddress(address);
-        return userRepository.save(user);
-    }
-
-    @Override
-    public Collection<User> getUsers() {
-        Collection<User> users = userRepository.findAll();
-        users.forEach(user -> {
-            try {
-                user.setAddress(addressService.getAddress(user.getAddressID()));
-            } catch (AddressNotFoundException e) {
-                throw new RuntimeException(e);
-            }
-        });
-        return users;
-    }
-
-    @Override
-    public User getUser(Long userID) throws UserNotFoundException, AddressNotFoundException {
-        User user = userRepository.findById(userID).orElseThrow(
-                ()-> new UserNotFoundException()
-        );
-        Address address = addressService.getAddress(user.getAddressID());
-        user.setAddress(address);
-
-        return user;
-    }
-
-    @Override
-    @Transactional
-    public User updateUser(Long userID, User user) throws UserNotFoundException, UserFieldsEmptyException,
-            AddressNotFoundException {
-        if (!UserValidator.isValidUser(user)){
-            throw new UserFieldsEmptyException();
-        }
-        Address address = addressService.getAddress(user.getAddressID());
-        if(address==null){
-            throw new AddressNotFoundException();
-        }
-
-        user = UserValidator.formatUser(user);
-
-        User savedUser = getUser(userID);
-        savedUser.setLastname(user.getLastname());
-        savedUser.setFirstname(user.getFirstname());
-        savedUser.setEmail(user.getEmail());
-        savedUser.setUserType(user.getUserType());
-        savedUser.setAddressID(user.getAddressID());
-        savedUser.setAddress(address);
-
-        return savedUser;
-    }
-
-    @Override
-    public void deleteUser(Long userID) throws UserNotFoundException, AddressNotFoundException {
-        userRepository.delete(getUser(userID));
-    }
-
-    @Override
-    public void deleteAllUsers() {
-        userRepository.deleteAll();
-    }
-
-    @Override
-    public Collection<User> getUsersLivingAtAddress(Long addressID) throws AddressNotFoundException {
-        Address address = addressService.getAddress(addressID);
-        if(address==null){
-            throw new AddressNotFoundException();
-        }
-
-        Collection<User> users = userRepository.findByAddressID(addressID);
-        users.forEach(user -> {
-            try {
-                user.setAddress(addressService.getAddress(user.getAddressID()));
-            } catch (AddressNotFoundException e) {
-                throw new RuntimeException(e);
-            }
-        });
-        return users;
-    }
-
+public interface UserService {
+    User createUser(User user) throws UserAlreadyExistsException, UserFieldsEmptyException, AddressNotFoundException;
+    Collection<User> getUsers();
+    Collection<User> getUsers(String firstname, String lastname);
+    User getUser(Long userID) throws UserNotFoundException, AddressNotFoundException;
+    User updateUser(Long userID, User user) throws UserNotFoundException, UserFieldsEmptyException, AddressNotFoundException;
+    void deleteUser(Long userID) throws UserNotFoundException, AddressNotFoundException;
+    void deleteAllUsers();
+    Collection<User> getUsersLivingAtAddress(Long addressID) throws AddressNotFoundException;
 }

user-microservice/src/main/java/fr/natan/microservices/usermicroservice/service/services/UserServiceImplement.java

@@ -0,0 +1,134 @@
+package fr.natan.microservices.usermicroservice.service.services;
+
+import fr.natan.microservices.usermicroservice.exceptions.AddressNotFoundException;
+import fr.natan.microservices.usermicroservice.exceptions.UserAlreadyExistsException;
+import fr.natan.microservices.usermicroservice.exceptions.UserFieldsEmptyException;
+import fr.natan.microservices.usermicroservice.exceptions.UserNotFoundException;
+import fr.natan.microservices.usermicroservice.model.User;
+import fr.natan.microservices.usermicroservice.repository.UserRepository;
+import fr.natan.microservices.usermicroservice.service.utilities.UserValidator;
+import fr.natan.microservices.usermicroservice.t_openfeign.model.Address;
+import fr.natan.microservices.usermicroservice.t_openfeign.service.AddressService;
+import org.springframework.stereotype.Service;
+
+import javax.transaction.Transactional;
+import java.sql.Date;
+import java.sql.Time;
+import java.util.Collection;
+
+@Service
+public class UserServiceImplement implements UserService {
+
+    private final UserRepository userRepository;
+    private final AddressService addressService;
+
+    public UserServiceImplement(UserRepository userRepository, AddressService addressService) {
+        this.userRepository = userRepository;
+        this.addressService = addressService;
+    }
+
+    @Override
+    public Collection<User> getUsers(String firstname, String lastname) {
+        return userRepository.findByFirstnameAndLastname(firstname, lastname);
+    }
+
+    @Override
+    public User createUser(User user) throws UserAlreadyExistsException, UserFieldsEmptyException, AddressNotFoundException {
+        if(!UserValidator.isValidUser(user)){
+            throw new UserFieldsEmptyException();
+        }
+        User formattedUser = UserValidator.formatUser(user);
+        if(getUsers(formattedUser.getFirstname(), formattedUser.getLastname()).size()>0){
+            throw new UserAlreadyExistsException();
+        }
+
+        user.setCreatedDate(new Date(System.currentTimeMillis()) + " : " + new Time(System.currentTimeMillis()));
+
+
+        Address address = addressService.getAddress(user.getAddressID());
+        if(address==null){
+            throw new AddressNotFoundException();
+        }
+        user.setAddressID(user.getAddressID());
+        user.setAddress(address);
+        return userRepository.save(user);
+    }
+
+    @Override
+    public Collection<User> getUsers() {
+        Collection<User> users = userRepository.findAll();
+        users.forEach(user -> {
+            try {
+                user.setAddress(addressService.getAddress(user.getAddressID()));
+            } catch (AddressNotFoundException e) {
+                throw new RuntimeException(e);
+            }
+        });
+        return users;
+    }
+
+    @Override
+    public User getUser(Long userID) throws UserNotFoundException, AddressNotFoundException {
+        User user = userRepository.findById(userID).orElseThrow(
+                ()-> new UserNotFoundException()
+        );
+        Address address = addressService.getAddress(user.getAddressID());
+        user.setAddress(address);
+
+        return user;
+    }
+
+    @Override
+    @Transactional
+    public User updateUser(Long userID, User user) throws UserNotFoundException, UserFieldsEmptyException,
+            AddressNotFoundException {
+        if (!UserValidator.isValidUser(user)){
+            throw new UserFieldsEmptyException();
+        }
+        Address address = addressService.getAddress(user.getAddressID());
+        if(address==null){
+            throw new AddressNotFoundException();
+        }
+
+        user = UserValidator.formatUser(user);
+
+        User savedUser = getUser(userID);
+        savedUser.setLastname(user.getLastname());
+        savedUser.setFirstname(user.getFirstname());
+        savedUser.setEmail(user.getEmail());
+        savedUser.setUserType(user.getUserType());
+        savedUser.setAddressID(user.getAddressID());
+        savedUser.setAddress(address);
+
+        return savedUser;
+    }
+
+    @Override
+    public void deleteUser(Long userID) throws UserNotFoundException, AddressNotFoundException {
+        userRepository.delete(getUser(userID));
+    }
+
+    @Override
+    public void deleteAllUsers() {
+        userRepository.deleteAll();
+    }
+
+    @Override
+    public Collection<User> getUsersLivingAtAddress(Long addressID) throws AddressNotFoundException {
+        Address address = addressService.getAddress(addressID);
+        if(address==null){
+            throw new AddressNotFoundException();
+        }
+
+        Collection<User> users = userRepository.findByAddressID(addressID);
+        users.forEach(user -> {
+            try {
+                user.setAddress(addressService.getAddress(user.getAddressID()));
+            } catch (AddressNotFoundException e) {
+                throw new RuntimeException(e);
+            }
+        });
+        return users;
+    }
+
+}

user-microservice/src/main/java/fr/natan/microservices/usermicroservice/tt_controller/UserController.java

@@ -5,7 +5,7 @@ import fr.natan.microservices.usermicroservice.exceptions.UserAlreadyExistsExcep
 import fr.natan.microservices.usermicroservice.exceptions.UserFieldsEmptyException;
 import fr.natan.microservices.usermicroservice.exceptions.UserNotFoundException;
 import fr.natan.microservices.usermicroservice.model.User;
-import fr.natan.microservices.usermicroservice.service.contract.UserContract;
+import fr.natan.microservices.usermicroservice.service.services.UserService;
 import fr.natan.microservices.usermicroservice.t_openfeign.service.AddressService;
 import org.springframework.web.bind.annotation.*;
 
@@ -13,10 +13,10 @@ import java.util.Collection;
 
 @RestController
 public class UserController {
-    private final UserContract userContract;
+    private final UserService userContract;
     private final AddressService addressService;
 
-    public UserController(UserContract userContract, AddressService addressService) {
+    public UserController(UserService userContract, AddressService addressService) {
         this.userContract = userContract;
         this.addressService = addressService;
     }