another commit

address-microservice/Dockerfile

+######
+##
+##  Stage 1: Building the app
+##
+#######
+
+FROM maven:3.8.3-adoptopenjdk-16 AS builder
+WORKDIR /build/
+COPY pom.xml /build/
+# fetch all dependencies
+#RUN mvn dependency:go-offline -B
+
+COPY src /build/src/
+RUN mvn package -DskipTests
+WORKDIR /build/target/
+RUN java -Djarmode=layertools -jar address-microservice-0.0.1-SNAPSHOT.jar extract
+######
+##
+##  Stage 2: Running the app
+##
+#######
+
+FROM adoptopenjdk:16_36-jre-hotspot
+RUN useradd -rm -d /home/zbook-pn-15-g3 -s /bin/bash -g root -G sudo -u 1001 simple-user
+USER simple-user
+WORKDIR application
+EXPOSE 8081
+ENTRYPOINT ["java", "org.springframework.boot.loader.JarLauncher"]
+COPY --from=builder /build/target/dependencies/ ./
+COPY --from=builder /build/target/spring-boot-loader/ ./
+COPY --from=builder /build/target/snapshot-dependencies/ ./
+COPY --from=builder /build/target/application/ ./

address-microservice/pom.xml

 					</excludes>
 				</configuration>
 			</plugin>
+			<plugin>
+				<artifactId>maven-surefire-plugin</artifactId>
+				<version>2.10</version>
+				<configuration>
+					<useFile>false</useFile>
+				</configuration>
+			</plugin>
 		</plugins>
 	</build>
 

address-microservice/src/main/java/fr/natan/addressmicroservice/AddressMicroserviceApplication.java

 package fr.natan.addressmicroservice;
 
+import fr.natan.addressmicroservice.entity.Address;
+import fr.natan.addressmicroservice.service.service.AddressService;
+import org.springframework.boot.CommandLineRunner;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.Bean;
+import org.springframework.data.rest.core.config.RepositoryRestConfiguration;
 
 @SpringBootApplication
 public class AddressMicroserviceApplication {

address-microservice/src/main/java/fr/natan/addressmicroservice/entity/Address.java

     private String streetName;
     private String pb;
     private String city;
-    private String country;
+    private String residenceCountry;
+    private String birthCountry;
 }

address-microservice/src/main/java/fr/natan/addressmicroservice/exceptions/AddressAlreadyExistsException.java

+package fr.natan.addressmicroservice.exceptions;
+
+public class AddressAlreadyExistsException extends Exception {
+}

address-microservice/src/main/java/fr/natan/addressmicroservice/exceptions/AddressNotFoundException.java

+package fr.natan.addressmicroservice.exceptions;
+
+public class AddressNotFoundException extends Exception {
+    public AddressNotFoundException(String message) {
+        super(message);
+    }
+}

address-microservice/src/main/java/fr/natan/addressmicroservice/exceptions/AddressnotFoundException.java

-package fr.natan.addressmicroservice.exceptions;
-
-public class AddressnotFoundException extends Exception {
-    public AddressnotFoundException(String message) {
-        super(message);
-    }
-}

address-microservice/src/main/java/fr/natan/addressmicroservice/exceptions_handler/AddressExceptionsHandler.java

+package fr.natan.addressmicroservice.exceptions_handler;
+
+import fr.natan.addressmicroservice.exceptions.AddressAlreadyExistsException;
+import fr.natan.addressmicroservice.exceptions.AddressNotFoundException;
+import fr.natan.addressmicroservice.exceptions.AddressOneOrMoreFieldsEmptyException;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+
+@ControllerAdvice
+public class AddressExceptionsHandler {
+
+    @ExceptionHandler(value = AddressNotFoundException.class)
+    private ResponseEntity<String> handleAddressNotFoundException(){
+        return new ResponseEntity<>("Address not found exception",
+                HttpStatus.NOT_FOUND);
+    }
+
+    @ExceptionHandler(value = AddressOneOrMoreFieldsEmptyException.class)
+    private ResponseEntity<String> handleAddressOneOrMoreFieldsEmptyException(){
+        return new ResponseEntity<>("Address, one or more fields empty exception",
+                HttpStatus.NOT_ACCEPTABLE);
+    }
+
+    @ExceptionHandler(value = AddressAlreadyExistsException.class)
+    private ResponseEntity<String> handleAddressAlreadyExistsException(){
+        return new ResponseEntity<>("Address already exists exception",
+                HttpStatus.NOT_ACCEPTABLE);
+    }
+}

address-microservice/src/main/java/fr/natan/addressmicroservice/repository/AddressRepository.java

 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.rest.core.annotation.RepositoryRestResource;
 
+import java.util.List;
+
 @RepositoryRestResource
 public interface AddressRepository extends JpaRepository<Address, Long> {
+    List<Address> findByNumHouseAndStreetNameAndPbAndCity(
+            String numHouse,
+            String streetName,
+            String pb,
+            String city);
 }

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

 package fr.natan.addressmicroservice.service.contract;
 
 import fr.natan.addressmicroservice.entity.Address;
-import fr.natan.addressmicroservice.exceptions.AddressnotFoundException;
+import fr.natan.addressmicroservice.exceptions.AddressAlreadyExistsException;
+import fr.natan.addressmicroservice.exceptions.AddressNotFoundException;
 import fr.natan.addressmicroservice.exceptions.AddressOneOrMoreFieldsEmptyException;
 
 import java.util.List;
 
 public interface AddressContract {
-    Address createAddress(Address address) throws AddressOneOrMoreFieldsEmptyException;
+    Address createAddress(Address address) throws AddressOneOrMoreFieldsEmptyException, AddressAlreadyExistsException;
     List<Address> getAllAddresses();
-    Address getAddressByID(Long addressID) throws AddressnotFoundException;
-    void deleteAddress(Long addressID) throws AddressnotFoundException;
-    Address updateAddress(Long addressID, Address address) throws AddressnotFoundException;
+    Address getAddressByID(Long addressID) throws AddressNotFoundException;
+    public List<Address> getAddressByNumHouseAndStreetNameAndPbAndCity(
+            String numHouse, String streetName, String pb, String city);
+    void deleteAddress(Long addressID) throws AddressNotFoundException;
+    Address updateAddress(Long addressID, Address address) throws AddressNotFoundException;
 }

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

 package fr.natan.addressmicroservice.service.service;
 
 import fr.natan.addressmicroservice.entity.Address;
+import fr.natan.addressmicroservice.exceptions.AddressAlreadyExistsException;
 import fr.natan.addressmicroservice.exceptions.AddressOneOrMoreFieldsEmptyException;
-import fr.natan.addressmicroservice.exceptions.AddressnotFoundException;
+import fr.natan.addressmicroservice.exceptions.AddressNotFoundException;
 import fr.natan.addressmicroservice.repository.AddressRepository;
 import fr.natan.addressmicroservice.service.contract.AddressContract;
 import org.springframework.stereotype.Service;
         address.setStreetName(address.getStreetName().strip());
         address.setPb(address.getPb().strip());
         address.setCity(address.getCity().strip());
-        address.setCountry(address.getCountry().strip());
-
+        address.setResidenceCountry(address.getResidenceCountry().strip());
+        address.setBirthCountry(address.getBirthCountry().strip());
         return address;
     }
 
                 || address.getStreetName().isEmpty()
                 || address.getPb().isEmpty()
                 || address.getCity().isEmpty()
-                || address.getCountry().isEmpty()
+                || address.getResidenceCountry().isEmpty()
+                || address.getBirthCountry().isEmpty()
         ){
             isInvalid=true;
         }
 
     }
     @Override
-    public Address createAddress(Address address) throws AddressOneOrMoreFieldsEmptyException {
+    public Address createAddress(Address address) throws AddressOneOrMoreFieldsEmptyException,
+            AddressAlreadyExistsException {
         address = addressNormalize(address);
        if(isValidAddress(address)){
            throw new AddressOneOrMoreFieldsEmptyException("one or more fields are empty");
        }
+
+        if(getAddressByNumHouseAndStreetNameAndPbAndCity(
+                address.getNumHouse(),
+                address.getStreetName(),
+                address.getPb(),
+                address.getCity()).size() > 0){
+
+            throw new AddressAlreadyExistsException();
+        }
         return addressRepository.save(address);
     }
 
     }
 
     @Override
-    public Address getAddressByID(Long addressID) throws AddressnotFoundException {
+    public Address getAddressByID(Long addressID) throws AddressNotFoundException {
         return addressRepository.findById(addressID).orElseThrow(
-                ()-> new AddressnotFoundException("address not found")
+                ()-> new AddressNotFoundException("address not found")
+        );
+    }
+
+    @Override
+    public List<Address> getAddressByNumHouseAndStreetNameAndPbAndCity(
+            String numHouse, String streetName, String pb, String city) {
+
+        return addressRepository.findByNumHouseAndStreetNameAndPbAndCity(
+                numHouse,
+                streetName,
+                pb,
+                city
         );
     }
 
     @Override
-    public void deleteAddress(Long addressID) throws AddressnotFoundException {
+    public void deleteAddress(Long addressID) throws AddressNotFoundException {
         Address address = addressRepository.findById(addressID).orElseThrow(
-                ()-> new AddressnotFoundException("address not found")
+                ()-> new AddressNotFoundException("address not found")
         );
         addressRepository.delete(address);
     }
 
     @Override
-    public Address updateAddress(Long addressID, Address address) throws AddressnotFoundException {
+    public Address updateAddress(Long addressID, Address address) throws AddressNotFoundException {
         if(getAddressByID(addressID)==null){
-            throw new AddressnotFoundException("address not found");
+            throw new AddressNotFoundException("address not found");
         }
 
         return addressRepository.save(address);

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

 package fr.natan.addressmicroservice.t_controllers;
 
 import fr.natan.addressmicroservice.entity.Address;
+import fr.natan.addressmicroservice.exceptions.AddressAlreadyExistsException;
 import fr.natan.addressmicroservice.exceptions.AddressOneOrMoreFieldsEmptyException;
-import fr.natan.addressmicroservice.exceptions.AddressnotFoundException;
+import fr.natan.addressmicroservice.exceptions.AddressNotFoundException;
 import fr.natan.addressmicroservice.service.service.AddressService;
 import org.springframework.web.bind.annotation.*;
 
     }
 
     @RequestMapping(value = "/addresses", method = RequestMethod.POST)
-    private Address createAddress(@RequestBody Address address) throws AddressOneOrMoreFieldsEmptyException {
+    private Address createAddress(@RequestBody Address address) throws AddressOneOrMoreFieldsEmptyException,
+            AddressAlreadyExistsException {
         return addressService.createAddress(address);
     }
 
     @RequestMapping(value = "/addresses/{addressID}", method = RequestMethod.DELETE)
-    private void deleteAddress(@PathVariable(name = "addressID") Long addressID) throws AddressnotFoundException {
+    private void deleteAddress(@PathVariable(name = "addressID") Long addressID) throws AddressNotFoundException {
         addressService.deleteAddress(addressID);
     }
 
     }
 
     @RequestMapping(value = "/addresses/{addressID}", method = RequestMethod.GET)
-    private Address getAddress(@PathVariable(name = "addressID") Long addressID) throws AddressnotFoundException {
+    private Address getAddress(@PathVariable(name = "addressID") Long addressID) throws AddressNotFoundException {
         return addressService.getAddressByID(addressID);
     }
 
     @RequestMapping(value = "/addresses/{addressID}")
-    private Address updateAddress(@PathVariable(name = "addressID") Long addressID, @RequestBody Address address) throws AddressnotFoundException {
+    private Address updateAddress(@PathVariable(name = "addressID") Long addressID, @RequestBody Address address) throws AddressNotFoundException {
         return addressService.updateAddress(addressID, address);
     }
 }

address-microservice/src/main/resources/application.properties

 server.port=8081
 spring.application.name=address-service
 spring.cloud.discovery.enabled=true
-eureka.client.service-url.defaultZone=http://localhost:8761/eureka
+#eureka.client.service-url.defaultZone=http://localhost:8761/eureka
+#for deployment in docker image, replace http://localhost:8761/eureka by the name of image in
+# docker compose, here the name of image is eureka-discovery-server
+eureka.client.service-url.defaultZone=http://eureka-discovery-server:8761/eureka
 ## address microservice database
-spring.datasource.url=jdbc:mysql://localhost:3306/address_microservice?createDatabaseIfNotExist=true
-spring.datasource.username =root
-spring.datasource.password = root
-spring.jpa.show-sql = true
-spring.jpa.hibernate.ddl-auto = update
-spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL8Dialect
+spring.datasource.url=jdbc:mysql://mysqldb:3306/address_microservice_db?createDatabaseIfNotExist=true
+spring.datasource.username=root
+spring.datasource.password=root
+spring.jpa.show-sql=true
+spring.jpa.hibernate.ddl-auto=update
+spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL8Dialect
 server.error.include-message=always

company-microservice/Dockerfile

+######
+##
+##  Stage 1: Building the app
+##
+#######
+
+FROM maven:3.8.3-adoptopenjdk-16 AS builder
+WORKDIR /build/
+COPY pom.xml /build/
+# fetch all dependencies
+#RUN mvn dependency:go-offline -B
+
+COPY src /build/src/
+RUN mvn package -DskipTests
+WORKDIR /build/target/
+RUN java -Djarmode=layertools -jar company-microservice-0.0.1-SNAPSHOT.jar extract
+######
+##
+##  Stage 2: Running the app
+##
+#######
+
+FROM adoptopenjdk:16_36-jre-hotspot
+RUN useradd -rm -d /home/zbook-pn-15-g3 -s /bin/bash -g root -G sudo -u 1001 simple-user
+USER simple-user
+WORKDIR application
+EXPOSE 8083
+ENTRYPOINT ["java", "org.springframework.boot.loader.JarLauncher"]
+COPY --from=builder /build/target/dependencies/ ./
+COPY --from=builder /build/target/spring-boot-loader/ ./
+COPY --from=builder /build/target/snapshot-dependencies/ ./
+COPY --from=builder /build/target/application/ ./

company-microservice/pom.xml

 					</excludes>
 				</configuration>
 			</plugin>
+			<plugin>
+				<artifactId>maven-surefire-plugin</artifactId>
+				<version>2.10</version>
+				<configuration>
+					<useFile>false</useFile>
+				</configuration>
+			</plugin>
 		</plugins>
 	</build>
 

company-microservice/src/main/java/fr/natan/companymicroservice/exceptions_handler/CompanyExceptionsHandler.java

+package fr.natan.companymicroservice.exceptions_handler;
+
+import fr.natan.companymicroservice.exceptions.CompanyNameAlreadyExistsException;
+import fr.natan.companymicroservice.exceptions.CompanyNameEmptyException;
+import fr.natan.companymicroservice.exceptions.CompanyNotFoundException;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+
+@ControllerAdvice
+public class CompanyExceptionsHandler {
+
+    @ExceptionHandler(value = CompanyNameAlreadyExistsException.class)
+    private ResponseEntity<String> handleCompanyNameAlreadyExistsException(){
+        return new ResponseEntity<>("Company name already exists exception",
+        HttpStatus.NOT_ACCEPTABLE);
+    }
+
+    @ExceptionHandler(value = CompanyNameEmptyException.class)
+    private ResponseEntity<String> handleCompanyNameEmptyException(){
+        return new ResponseEntity<>("Company name is empty exception",
+                HttpStatus.NOT_ACCEPTABLE);
+    }
+
+    @ExceptionHandler(value = CompanyNotFoundException.class)
+    private ResponseEntity<String> handleCompanyNotFoundException(){
+        return new ResponseEntity<>("Company not found exception",
+                HttpStatus.NOT_FOUND);
+    }
+}

company-microservice/src/main/resources/application.properties

 server.port=8083
 spring.application.name=company-service
 spring.cloud.discovery.enabled=true
-eureka.client.service-url.defaultZone=http://localhost:8761/eureka
+
+#eureka.client.service-url.defaultZone=http://localhost:8761/eureka
+#eureka.client.service-url.defaultZone=http://localhost:8761/eureka
+#for deployment in docker image, replace http://localhost:8761/eureka by the name of image in
+# docker compose, here the name of image is eureka-discovery-server
+eureka.client.service-url.defaultZone=http://eureka-discovery-server:8761/eureka
 
 ## company microservice database
-spring.datasource.url=jdbc:mysql://localhost:3306/company_microservice?createDatabaseIfNotExist=true
+spring.datasource.url=jdbc:mysql://mysqldb:3306/company_microservice_db?createDatabaseIfNotExist=true
 spring.datasource.username =root
 spring.datasource.password = root
 spring.jpa.show-sql = true

docker-compose.yml

+version: '3.4'
+
+services:
+    
+    mysqldb:
+        image: mysql:8.0
+        container_name: mysqldb
+        restart: always
+        ports:
+          - "3036:3036"
+        networks:
+            - microservices
+        environment:
+            MYSQL_ROOT_PASSWORD: root
+    
+    eureka-discovery-server:
+        image: eureka-discovery-server:latest
+        container_name: eureka-discovery-server
+        build:
+            context: ./eureka-discovery-server
+            dockerfile: Dockerfile
+        ports:
+            - "8761:8761"
+        networks:
+            - microservices
+
+    spring-cloug-gateway:
+        image: spring-cloug-gateway:latest
+        container_name: spring-cloud-gateway
+        build:
+            context: ./spring-cloud-gateway-service
+            dockerfile: Dockerfile
+        ports:
+            - "8888:8888"
+        links:
+            - eureka-discovery-server
+        networks:
+            - microservices
+        depends_on:
+            - eureka-discovery-server
+
+    address-microservice:
+        image: address-microservice:latest
+        container_name: address-microservice
+        build:
+            context: ./address-microservice
+            dockerfile: Dockerfile
+        ports:
+              - "8081:8081"
+        links:
+            - eureka-discovery-server
+        networks:
+            - microservices
+        depends_on:
+            - eureka-discovery-server
+
+    employee-microservice:
+        image: employee-microservice:latest
+        container_name: employee-microservice
+        build:
+            context: ./employee-microservice
+            dockerfile: Dockerfile
+        ports:
+              - "8082:8082"
+        links:
+            - eureka-discovery-server
+        networks:
+            - microservices
+        depends_on:
+            - eureka-discovery-server
+
+    company-microservice:
+        image: company-microservice:latest
+        container_name: company-microservice
+        build:
+            context: ./company-microservice
+            dockerfile: Dockerfile
+        ports:
+            - "8083:8083"
+        links:
+            - eureka-discovery-server
+        networks:
+            - microservices
+        depends_on:
+            - eureka-discovery-server
+
+    project-microservice:
+        image: project-microservice:latest
+        container_name: project-microservice
+        build:
+            context: ./project-microservice
+            dockerfile: Dockerfile
+        ports:
+            - "8084:8084"
+        links:
+            - eureka-discovery-server
+        networks:
+            - microservices
+        depends_on:
+            - eureka-discovery-server
+networks:
+    microservices:

employee-microservice/Dockerfile

+######
+##
+##  Stage 1: Building the app
+##
+#######
+
+FROM maven:3.8.3-adoptopenjdk-16 AS builder
+WORKDIR /build/
+COPY pom.xml /build/
+# fetch all dependencies
+#RUN mvn dependency:go-offline -B
+
+COPY src /build/src/
+RUN mvn package -DskipTests
+WORKDIR /build/target/
+RUN java -Djarmode=layertools -jar employee-microservice-0.0.1-SNAPSHOT.jar extract
+######
+##
+##  Stage 2: Running the app
+##
+#######
+
+FROM adoptopenjdk:16_36-jre-hotspot
+RUN useradd -rm -d /home/zbook-pn-15-g3 -s /bin/bash -g root -G sudo -u 1001 simple-user
+USER simple-user
+WORKDIR application
+EXPOSE 8082
+ENTRYPOINT ["java", "org.springframework.boot.loader.JarLauncher"]
+COPY --from=builder /build/target/dependencies/ ./
+COPY --from=builder /build/target/spring-boot-loader/ ./
+COPY --from=builder /build/target/snapshot-dependencies/ ./
+COPY --from=builder /build/target/application/ ./

employee-microservice/pom.xml

 		</dependencies>
 	</dependencyManagement>
 
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>org.springframework.boot</groupId>
+				<artifactId>spring-boot-maven-plugin</artifactId>
+				<configuration>
+					<excludes>
+						<exclude>
+							<groupId>org.project-lombok</groupId>
+							<artifactId>lombok</artifactId>
+						</exclude>
+					</excludes>
+				</configuration>
+			</plugin>
+			<plugin>
+				<artifactId>maven-surefire-plugin</artifactId>
+				<version>2.10</version>
+				<configuration>
+					<useFile>false</useFile>
+				</configuration>
+			</plugin>
+		</plugins>
+	</build>
+
 
 </project>

employee-microservice/src/main/java/fr/natan/employeemicroservice/entity/Employee.java

 import javax.persistence.*;
 
 @Entity
-@Data
-@AllArgsConstructor
-@NoArgsConstructor
 public class Employee {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long addressID;
     @Transient
     private Address address;
+
+    public Employee(Long employeeID, String firstname, String lastname, String email, String createdDate,
+                    Long addressID, Address address) {
+        this.employeeID = employeeID;
+        this.firstname = firstname;
+        this.lastname = lastname;
+        this.email = email;
+        this.createdDate = createdDate;
+        this.addressID = addressID;
+        this.address = address;
+    }
+
+    public Employee() {
+    }
+
+    public Long getEmployeeID() {
+        return employeeID;
+    }
+
+    public void setEmployeeID(Long employeeID) {
+        this.employeeID = employeeID;
+    }
+
+    public String getFirstname() {
+        return firstname;
+    }
+
+    public void setFirstname(String firstname) {
+        this.firstname = firstname;
+    }
+
+    public String getLastname() {
+        return lastname;
+    }
+
+    public void setLastname(String lastname) {
+        this.lastname = lastname;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    public String getCreatedDate() {
+        return createdDate;
+    }
+
+    public void setCreatedDate(String createdDate) {
+        this.createdDate = createdDate;
+    }
+
+    public Long getAddressID() {
+        return addressID;
+    }
+
+    public void setAddressID(Long addressID) {
+        this.addressID = addressID;
+    }
+
+    public Address getAddress() {
+        return address;
+    }
+
+    public void setAddress(Address address) {
+        this.address = address;
+    }
 }

employee-microservice/src/main/java/fr/natan/employeemicroservice/exceptions_handler/EmployeeExceptionHandler.java

+package fr.natan.employeemicroservice.exceptions_handler;
+
+import fr.natan.employeemicroservice.exceptions.AddressNotFoundException;
+import fr.natan.employeemicroservice.exceptions.EmployeeAlreadyExistsException;
+import fr.natan.employeemicroservice.exceptions.EmployeeNotFoundException;
+import fr.natan.employeemicroservice.exceptions.EmployeeOneOrMoreFieldsEmptyException;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+
+@ControllerAdvice
+public class EmployeeExceptionHandler {
+
+    @ExceptionHandler(value = AddressNotFoundException.class)
+    private ResponseEntity<String> handlerAddressNotFoundException(){
+        return new ResponseEntity<>("Address to affect employee not found exception",
+                HttpStatus.NOT_FOUND);
+    }
+
+    @ExceptionHandler(value = EmployeeAlreadyExistsException.class)
+    private ResponseEntity<String> handleEmployeeAlreadyExistsException(){
+        return new ResponseEntity<>("Employee with same firstname and lastname already exists exception",
+                HttpStatus.NOT_ACCEPTABLE);
+    }
+
+    @ExceptionHandler(value = EmployeeNotFoundException.class)
+    private ResponseEntity<String> handleEmployeeNotFoundException(){
+        return new ResponseEntity<>("Employee not found exception",
+                HttpStatus.NOT_FOUND);
+    }
+
+    @ExceptionHandler(value = EmployeeOneOrMoreFieldsEmptyException.class)
+    private ResponseEntity<String> handleEmployeeOneOrMoreFieldsEmptyException(){
+        return new ResponseEntity<>("Employee, one or more fields empty exception",
+                HttpStatus.NOT_ACCEPTABLE);
+    }
+}

employee-microservice/src/main/java/fr/natan/employeemicroservice/service/services/EmployeeService.java

     private Employee normalizeEmployee(Employee employee){
         employee.setFirstname(employee.getFirstname().strip());
         employee.setLastname(employee.getLastname().strip());
+        employee.setLastname(employee.getLastname().toUpperCase());
 
         return employee;
     }
         if(address==null){
             throw new AddressNotFoundException("Address to affect new employee is not found");
         }
-        Employee saveEmployee = getEmployeeByName(employee.getFirstname(), employee.getLastname());
-        if(saveEmployee!= null){
+        Employee saveToEmployee = getEmployeeByName(employee.getFirstname(), employee.getLastname());
+        if(saveToEmployee!= null){
             throw new EmployeeAlreadyExistsException("employee already exists");
         }
         employee.setEmail(
                 )
         );
         employee.setAddressID(addressID);
+        employee.setAddress(address);
         employee.setCreatedDate(new Date(System.currentTimeMillis()) +" : "+ new Time(System.currentTimeMillis()));
+
         return employeeRepository.save(employee);
     }
 

employee-microservice/src/main/java/fr/natan/employeemicroservice/t_openFeign/address/Address.java

     private String streetName;
     private int pb;
     private String city;
-    private String country;
+    private String residenceCountry;
+    private String birthCountry;
 }

employee-microservice/src/main/resources/application.properties

 server.port=8082
 spring.application.name=employee-service
 spring.cloud.discovery.enabled=true
-eureka.client.service-url.defaultZone=http://localhost:8761/eureka
+#eureka.client.service-url.defaultZone=http://localhost:8761/eureka
+#eureka.client.service-url.defaultZone=http://localhost:8761/eureka
+#for deployment in docker image, replace http://localhost:8761/eureka by the name of image in
+# docker compose, here the name of image is eureka-discovery-server
+eureka.client.service-url.defaultZone=http://eureka-discovery-server:8761/eureka
 
 ## employee microservice database
-spring.datasource.url=jdbc:mysql://localhost:3306/employee_microservice?createDatabaseIfNotExist=true
+spring.datasource.url=jdbc:mysql://mysqldb:3306/employee_microservice_db?createDatabaseIfNotExist=true
 spring.datasource.username =root
 spring.datasource.password = root
 spring.jpa.show-sql = true

eureka-discovery-service/.mvn/wrapper/maven-wrapper.properties → eureka-discovery-server/.mvn/wrapper/maven-wrapper.properties

-distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.8.5/apache-maven-3.8.5-bin.zip
+distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.8.6/apache-maven-3.8.6-bin.zip
 wrapperUrl=https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar

eureka-discovery-server/Dockerfile

+######
+##
+##  Stage 1: Building the app
+##
+#######
+
+FROM maven:3.8.3-adoptopenjdk-16 AS builder
+WORKDIR /build/
+COPY pom.xml /build/
+# fetch all dependencies
+#RUN mvn dependency:go-offline -B
+
+COPY src /build/src/
+RUN mvn package -DskipTests
+WORKDIR /build/target/
+RUN java -Djarmode=layertools -jar eureka-discovery-server-0.0.1-SNAPSHOT.jar extract
+######
+##
+##  Stage 2: Running the app
+##
+#######
+
+FROM adoptopenjdk:16_36-jre-hotspot
+RUN useradd -rm -d /home/zbook-pn-15-g3 -s /bin/bash -g root -G sudo -u 1001 simple-user
+USER simple-user
+WORKDIR application
+EXPOSE 8761
+ENTRYPOINT ["java", "org.springframework.boot.loader.JarLauncher"]
+COPY --from=builder /build/target/dependencies/ ./
+COPY --from=builder /build/target/spring-boot-loader/ ./
+COPY --from=builder /build/target/snapshot-dependencies/ ./
+COPY --from=builder /build/target/application/ ./

eureka-discovery-service/pom.xml → eureka-discovery-server/pom.xml

 	<parent>
 		<groupId>org.springframework.boot</groupId>
 		<artifactId>spring-boot-starter-parent</artifactId>
-		<version>2.7.1</version>
+		<version>2.7.3</version>
 		<relativePath/> <!-- lookup parent from repository -->
 	</parent>
-	<groupId>fr.natan</groupId>
-	<artifactId>eureka-discovery-service</artifactId>
+	<groupId>fr.natan.eurekadiscoveryserver</groupId>
+	<artifactId>eureka-discovery-server</artifactId>
 	<version>0.0.1-SNAPSHOT</version>
-	<name>eureka-discovery-service</name>
+	<name>eureka-discovery-server</name>
 	<description>service d enregistrement des microservices</description>
 	<properties>
 		<java.version>11</java.version>
-		<spring-cloud.version>2021.0.3</spring-cloud.version>
+		<spring-cloud.version>2021.0.4</spring-cloud.version>
 	</properties>
 	<dependencies>
 		<dependency>
 		</dependencies>
 	</dependencyManagement>
 
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>org.springframework.boot</groupId>
+				<artifactId>spring-boot-maven-plugin</artifactId>
+			</plugin>
+		</plugins>
+	</build>
+
 </project>

eureka-discovery-service/src/main/java/fr/natan/eurekadiscoveryservice/EurekaDiscoveryServiceApplication.java → eureka-discovery-server/src/main/java/fr/natan/eurekadiscoveryserver/eurekadiscoveryserver/EurekaDiscoveryServerApplication.java

-package fr.natan.eurekadiscoveryservice;
+package fr.natan.eurekadiscoveryserver.eurekadiscoveryserver;
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 
 @SpringBootApplication
 @EnableEurekaServer
-public class EurekaDiscoveryServiceApplication {
+public class EurekaDiscoveryServerApplication {
 
 	public static void main(String[] args) {
-		SpringApplication.run(EurekaDiscoveryServiceApplication.class, args);
+		SpringApplication.run(EurekaDiscoveryServerApplication.class, args);
 	}
 
 }

eureka-discovery-service/src/main/resources/application.properties → eureka-discovery-server/src/main/resources/application.properties

 server.port=8761
 eureka.client.register-with-eureka=false
-eureka.client.fetch-registry=false
+eureka.client.fetch-registry=false

eureka-discovery-service/src/test/java/fr/natan/eurekadiscoveryservice/EurekaDiscoveryServiceApplicationTests.java → eureka-discovery-server/src/test/java/fr/natan/eurekadiscoveryserver/eurekadiscoveryserver/EurekaDiscoveryServerApplicationTests.java

-package fr.natan.eurekadiscoveryservice;
+package fr.natan.eurekadiscoveryserver.eurekadiscoveryserver;
 
 import org.junit.jupiter.api.Test;
 import org.springframework.boot.test.context.SpringBootTest;
 
 @SpringBootTest
-class EurekaDiscoveryServiceApplicationTests {
+class EurekaDiscoveryServerApplicationTests {
 
 	@Test
 	void contextLoads() {

project-microservice/Dockerfile

+######
+##
+##  Stage 1: Building the app
+##
+#######
+
+FROM maven:3.8.3-adoptopenjdk-16 AS builder
+WORKDIR /build/
+COPY pom.xml /build/
+# fetch all dependencies
+#RUN mvn dependency:go-offline -B
+
+COPY src /build/src/
+RUN mvn package -DskipTests
+WORKDIR /build/target/
+RUN java -Djarmode=layertools -jar project-microservice-0.0.1-SNAPSHOT.jar extract
+######
+##
+##  Stage 2: Running the app
+##
+#######
+
+FROM adoptopenjdk:16_36-jre-hotspot
+RUN useradd -rm -d /home/zbook-pn-15-g3 -s /bin/bash -g root -G sudo -u 1001 simple-user
+USER simple-user
+WORKDIR application
+EXPOSE 8084
+ENTRYPOINT ["java", "org.springframework.boot.loader.JarLauncher"]
+COPY --from=builder /build/target/dependencies/ ./
+COPY --from=builder /build/target/spring-boot-loader/ ./
+COPY --from=builder /build/target/snapshot-dependencies/ ./
+COPY --from=builder /build/target/application/ ./

project-microservice/pom.xml

 		</dependencies>
 	</dependencyManagement>
 
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>org.springframework.boot</groupId>
+				<artifactId>spring-boot-maven-plugin</artifactId>
+				<configuration>
+					<excludes>
+						<exclude>
+							<groupId>org.project-lombok</groupId>
+							<artifactId>lombok</artifactId>
+						</exclude>
+					</excludes>
+				</configuration>
+			</plugin>
+			<plugin>
+				<artifactId>maven-surefire-plugin</artifactId>
+				<version>2.10</version>
+				<configuration>
+					<useFile>false</useFile>
+				</configuration>
+			</plugin>
+		</plugins>
+
+	</build>
+
 </project>

project-microservice/src/main/java/fr/natan/projectmicroservice/exceptions_handler/ProjectExceptionsHandler.java

+package fr.natan.projectmicroservice.exceptions_handler;
+
+import fr.natan.projectmicroservice.exceptions.*;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+
+@ControllerAdvice
+public class ProjectExceptionsHandler {
+
+    @ExceptionHandler(value = CompanyNotFoundException.class)
+    private ResponseEntity<String> handleCompanyNotFoundException(){
+        return new ResponseEntity<>("Company for this project not found exception",
+                HttpStatus.NOT_ACCEPTABLE);
+    }
+
+    @ExceptionHandler(value = EmployeeNotFoundException.class)
+    private ResponseEntity<String> handleEmployeeNotFoundException(){
+        return new ResponseEntity<>("Employee for this project not found exception",
+                HttpStatus.NOT_ACCEPTABLE);
+    }
+    @ExceptionHandler(value = ProjectAlreadyExistsException.class)
+    private ResponseEntity<String> handleProjectAlreadyExistsException(){
+        return new ResponseEntity<>("Project already exists exception",
+                HttpStatus.NOT_ACCEPTABLE);
+    }
+    @ExceptionHandler(value = ProjectDescriptionShortException.class)
+    private ResponseEntity<String> handleProjectDescriptionShortException(){
+        return new ResponseEntity<>("Project description is short exception",
+                HttpStatus.NOT_ACCEPTABLE);
+    }
+    @ExceptionHandler(value = ProjectNotFoundException.class)
+    private ResponseEntity<String> handleProjectNotFoundException(){
+        return new ResponseEntity<>("Project not found exception",
+                HttpStatus.NOT_FOUND);
+    }
+    @ExceptionHandler(value = ProjectOneOrMoreFieldsInvalidException.class)
+    private ResponseEntity<String> handleProjectOneOrMoreFieldsInvalidException(){
+        return new ResponseEntity<>("Project, one or more fields empty exception",
+                HttpStatus.NOT_ACCEPTABLE);
+    }
+}

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

             throw new ProjectDescriptionShortException("short project description");
         }
         //test if employee and company to which project is affected exist
-        getEmployee(employeeID);
-        getCompany(companyID);
+        Employee employee = getEmployee(employeeID);
+        Company company = getCompany(companyID);
 
         Project savedProject = getProjectByName(project.getProjectName());
         if(savedProject!=null){
         project.setCreatedDate(new Date(System.currentTimeMillis())+" : "+new Time(System.currentTimeMillis()));
         project.setEmployeeID(employeeID);
         project.setCompanyID(companyID);
+        project.setEmployee(employee);
+        project.setCompany(company);
+
         return projectRepository.save(project);
     }
 

project-microservice/src/main/resources/application.properties

 server.port=8084
 spring.application.name=project-service
 spring.cloud.discovery.enabled=true
-eureka.client.service-url.defaultZone=http://localhost:8761/eureka
+#eureka.client.service-url.defaultZone=http://localhost:8761/eureka
+#eureka.client.service-url.defaultZone=http://localhost:8761/eureka
+#for deployment in docker image, replace http://localhost:8761/eureka by the name of image in
+# docker compose, here the name of image is eureka-discovery-server
+eureka.client.service-url.defaultZone=http://eureka-discovery-server:8761/eureka
 
 ## project microservice database
-spring.datasource.url=jdbc:mysql://localhost:3306/project_microservice?createDatabaseIfNotExist=true
+spring.datasource.url=jdbc:mysql://mysqldb:3306/project_microservice_db?createDatabaseIfNotExist=true
 spring.datasource.username =root
 spring.datasource.password = root
 spring.jpa.show-sql = true

spring-cloud-gateway-service/Dockerfile

+######
+##
+##  Stage 1: Building the app
+##
+#######
+
+FROM maven:3.8.3-adoptopenjdk-16 AS builder
+WORKDIR /build/
+COPY pom.xml /build/
+# fetch all dependencies
+#RUN mvn dependency:go-offline -B
+
+COPY src /build/src/
+RUN mvn package -DskipTests
+WORKDIR /build/target/
+RUN java -Djarmode=layertools -jar spring-cloud-gateway-service-0.0.1-SNAPSHOT.jar extract
+######
+##
+##  Stage 2: Running the app
+##
+#######
+
+FROM adoptopenjdk:16_36-jre-hotspot
+RUN useradd -rm -d /home/zbook-pn-15-g3 -s /bin/bash -g root -G sudo -u 1001 simple-user
+USER simple-user
+WORKDIR application
+EXPOSE 8888
+ENTRYPOINT ["java", "org.springframework.boot.loader.JarLauncher"]
+COPY --from=builder /build/target/dependencies/ ./
+COPY --from=builder /build/target/spring-boot-loader/ ./
+COPY --from=builder /build/target/snapshot-dependencies/ ./
+COPY --from=builder /build/target/application/ ./

spring-cloud-gateway-service/pom.xml

 		</dependencies>
 	</dependencyManagement>
 
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>org.springframework.boot</groupId>
+				<artifactId>spring-boot-maven-plugin</artifactId>
+			</plugin>
+		</plugins>
+	</build>
+
 </project>

spring-cloud-gateway-service/src/main/resources/application.properties

 server.port=8888
-spring.application.name=gateway-service
-spring.cloud.discovery.enabled=true
+spring.application.name=spring-cloud-gateway-service
+spring.cloud.discovery.enabled=true
+#eureka.client.service-url.defaultZone=http://localhost:8761/eureka
+#eureka.client.service-url.defaultZone=http://localhost:8761/eureka
+#for deployment in docker image, replace http://localhost:8761/eureka by the name of image in
+# docker compose, here the name of image is eureka-discovery-server
+eureka.client.service-url.defaultZone=http://eureka-discovery-server:8761/eureka