commit second

project-microservice/src/main/java/fr/natan/microservices/projectmicroservice/model/entity/Project.java

 import fr.natan.microservices.projectmicroservice.model.enumType.Priority;
 import fr.natan.microservices.projectmicroservice.model.enumType.ProjState;
 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.models.user.AppUser;
 
 import javax.persistence.*;
 
     private String description;
     private Long userID;
     @Transient
-    private User user;
+    private AppUser user;
 
     public Project() {
     }
             Long projectID, String projectName,
             Priority projectPriority, String createDate,
             Long companyID, Company company, String description,
-            Long userID, User user, ProjState projectProgress) {
+            Long userID, AppUser user, ProjState projectProgress) {
 
         this.projectID = projectID;
         this.projectName = projectName;
         this.userID = userID;
     }
 
-    public User getUser() {
+    public AppUser getUser() {
         return user;
     }
 
-    public void setUser(User user) {
+    public void setUser(AppUser user) {
         this.user = user;
     }
 

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

 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.models.user.AppUser;
 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;
         }
 
         Project formattedProject = ProjectValidator.formatProject(project);
-        User user = userService.getUserByID(project.getUserID());
+        AppUser user = userService.getUserByID(project.getUserID());
         Address address = addressService.getAddressByID(user.getAddressID());
         user.setAddress(address);
 

project-microservice/src/main/java/fr/natan/microservices/projectmicroservice/t_openfeign/models/user/User.java → project-microservice/src/main/java/fr/natan/microservices/projectmicroservice/t_openfeign/models/user/AppUser.java

 
 import fr.natan.microservices.projectmicroservice.t_openfeign.models.address.Address;
 
-public class User {
+public class AppUser {
     private Long userID;
     private String firstname;
     private String lastname;
     private Long addressID;
     private Address address;
 
-    public User() {
+    public AppUser() {
     }
 
-    public User(Long userID, String firstname, String lastname, String email,
-                String createdDate, Long addressID, Address address) {
+    public AppUser(Long userID, String firstname, String lastname, String email,
+                   String createdDate, Long addressID, Address address) {
         this.userID = userID;
         this.firstname = firstname;
         this.lastname = lastname;

project-microservice/src/main/java/fr/natan/microservices/projectmicroservice/t_openfeign/services/UserService.java

 
 
 import fr.natan.microservices.projectmicroservice.module_exception.exceptions.UserNotFoundException;
-import fr.natan.microservices.projectmicroservice.t_openfeign.models.user.User;
+import fr.natan.microservices.projectmicroservice.t_openfeign.models.user.AppUser;
 import org.springframework.cloud.openfeign.FeignClient;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.RequestMapping;
 public interface UserService {
 
     @RequestMapping(value = "/users/{userID}", method = RequestMethod.GET)
-    User getUserByID(@PathVariable(name = "userID") Long userID) throws UserNotFoundException;
+    AppUser getUserByID(@PathVariable(name = "userID") Long userID) throws UserNotFoundException;
 }

user-microservice/src/main/java/fr/natan/microservices/usermicroservice/model/User.java → user-microservice/src/main/java/fr/natan/microservices/usermicroservice/model/AppUser.java

 
 @Entity
 @Table(name = "users")
-public class User {
+public class AppUser {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long userID;
     @Transient
     private Address address;
 
-    public User() {
+    public AppUser() {
     }
 
-    public User(Long userID, String firstname, String lastname,
-                String email, String createdDate, UserType userType,
-                Long addressID, Address address) {
+    public AppUser(Long userID, String firstname, String lastname,
+                   String email, String createdDate, UserType userType,
+                   Long addressID, Address address) {
         this.userID = userID;
         this.firstname = firstname;
         this.lastname = lastname;

user-microservice/src/main/java/fr/natan/microservices/usermicroservice/repository/UserRepository.java

 package fr.natan.microservices.usermicroservice.repository;
 
-import fr.natan.microservices.usermicroservice.model.User;
+import fr.natan.microservices.usermicroservice.model.AppUser;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
 
 import java.util.Collection;
 
 @Repository
-public interface UserRepository extends JpaRepository<User, Long> {
-    Collection<User> findByFirstnameAndLastname(String firstname, String lastname);
-    Collection<User> findByAddressID(Long addressID);
+public interface UserRepository extends JpaRepository<AppUser, Long> {
+    Collection<AppUser> findByFirstnameAndLastname(String firstname, String lastname);
+    Collection<AppUser> findByAddressID(Long addressID);
 }

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

 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.model.AppUser;
 
 import java.util.Collection;
 
 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;
+    AppUser createUser(AppUser user) throws UserAlreadyExistsException, UserFieldsEmptyException, AddressNotFoundException;
+    Collection<AppUser> getUsers();
+    Collection<AppUser> getUsers(String firstname, String lastname);
+    AppUser getUser(Long userID) throws UserNotFoundException, AddressNotFoundException;
+    AppUser updateUser(Long userID, AppUser user) throws UserNotFoundException, UserFieldsEmptyException, AddressNotFoundException;
     void deleteUser(Long userID) throws UserNotFoundException, AddressNotFoundException;
     void deleteAllUsers();
-    Collection<User> getUsersLivingAtAddress(Long addressID) throws AddressNotFoundException;
+    Collection<AppUser> getUsersLivingAtAddress(Long addressID) throws AddressNotFoundException;
 }

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

 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.model.AppUser;
 import fr.natan.microservices.usermicroservice.repository.UserRepository;
 import fr.natan.microservices.usermicroservice.service.utilities.UserValidator;
 import fr.natan.microservices.usermicroservice.t_openfeign.model.Address;
     }
 
     @Override
-    public Collection<User> getUsers(String firstname, String lastname) {
+    public Collection<AppUser> getUsers(String firstname, String lastname) {
         return userRepository.findByFirstnameAndLastname(firstname, lastname);
     }
 
     @Override
-    public User createUser(User user) throws UserAlreadyExistsException, UserFieldsEmptyException, AddressNotFoundException {
+    public AppUser createUser(AppUser user) throws UserAlreadyExistsException, UserFieldsEmptyException, AddressNotFoundException {
         if(!UserValidator.isValidUser(user)){
             throw new UserFieldsEmptyException();
         }
-        User formattedUser = UserValidator.formatUser(user);
+        AppUser formattedUser = UserValidator.formatUser(user);
         if(getUsers(formattedUser.getFirstname(), formattedUser.getLastname()).size()>0){
             throw new UserAlreadyExistsException();
         }
     }
 
     @Override
-    public Collection<User> getUsers() {
-        Collection<User> users = userRepository.findAll();
+    public Collection<AppUser> getUsers() {
+        Collection<AppUser> users = userRepository.findAll();
         users.forEach(user -> {
             try {
                 user.setAddress(addressService.getAddress(user.getAddressID()));
     }
 
     @Override
-    public User getUser(Long userID) throws UserNotFoundException, AddressNotFoundException {
-        User user = userRepository.findById(userID).orElseThrow(
+    public AppUser getUser(Long userID) throws UserNotFoundException, AddressNotFoundException {
+        AppUser user = userRepository.findById(userID).orElseThrow(
                 ()-> new UserNotFoundException()
         );
         Address address = addressService.getAddress(user.getAddressID());
 
     @Override
     @Transactional
-    public User updateUser(Long userID, User user) throws UserNotFoundException, UserFieldsEmptyException,
+    public AppUser updateUser(Long userID, AppUser user) throws UserNotFoundException, UserFieldsEmptyException,
             AddressNotFoundException {
         if (!UserValidator.isValidUser(user)){
             throw new UserFieldsEmptyException();
 
         user = UserValidator.formatUser(user);
 
-        User savedUser = getUser(userID);
+        AppUser savedUser = getUser(userID);
         savedUser.setLastname(user.getLastname());
         savedUser.setFirstname(user.getFirstname());
         savedUser.setEmail(user.getEmail());
     }
 
     @Override
-    public Collection<User> getUsersLivingAtAddress(Long addressID) throws AddressNotFoundException {
+    public Collection<AppUser> getUsersLivingAtAddress(Long addressID) throws AddressNotFoundException {
         Address address = addressService.getAddress(addressID);
         if(address==null){
             throw new AddressNotFoundException();
         }
 
-        Collection<User> users = userRepository.findByAddressID(addressID);
+        Collection<AppUser> users = userRepository.findByAddressID(addressID);
         users.forEach(user -> {
             try {
                 user.setAddress(addressService.getAddress(user.getAddressID()));

user-microservice/src/main/java/fr/natan/microservices/usermicroservice/service/utilities/UserValidator.java

 package fr.natan.microservices.usermicroservice.service.utilities;
 
-import fr.natan.microservices.usermicroservice.model.User;
+import fr.natan.microservices.usermicroservice.model.AppUser;
 
 public class UserValidator {
 
-    public static boolean isValidUser(User user) {
+    public static boolean isValidUser(AppUser user) {
         if (
                 user.getFirstname().isEmpty()
                         || user.getLastname().isEmpty()
             return true;
     }
 
-    public static User formatUser(User user) {
+    public static AppUser formatUser(AppUser user) {
         user.setLastname(user.getLastname().strip().toUpperCase());
         user.setFirstname(user.getFirstname().strip());
         user.setUserType(user.getUserType());

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

 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.model.AppUser;
 import fr.natan.microservices.usermicroservice.service.services.UserService;
 import fr.natan.microservices.usermicroservice.t_openfeign.service.AddressService;
 import org.springframework.web.bind.annotation.*;
     }
 
     @RequestMapping(value = "/users", method = RequestMethod.POST)
-    private User createUser(@RequestBody User user)
+    private AppUser createUser(@RequestBody AppUser user)
             throws UserFieldsEmptyException, AddressNotFoundException, UserAlreadyExistsException {
         return userContract.createUser(user);
     }
 
     @RequestMapping(value = "/users", method = RequestMethod.GET)
-    private Collection<User> getAllUsers() {
+    private Collection<AppUser> getAllUsers() {
         return userContract.getUsers();
     }
 
     @RequestMapping(value = "/users/{userID}", method = RequestMethod.GET)
-    private User getUser(@PathVariable(name = "userID") Long userID) throws UserNotFoundException, AddressNotFoundException {
+    private AppUser getUser(@PathVariable(name = "userID") Long userID) throws UserNotFoundException, AddressNotFoundException {
         return userContract.getUser(userID);
     }
 
     }
 
     @RequestMapping(value = "/users/{userID}", method = RequestMethod.PUT)
-    private User updateUser(@PathVariable(name = "userID") Long userID, @RequestBody User user)
+    private AppUser updateUser(@PathVariable(name = "userID") Long userID, @RequestBody AppUser user)
             throws UserNotFoundException, UserFieldsEmptyException, AddressNotFoundException {
         return userContract.updateUser(userID, user);
     }
 
     @RequestMapping(value = "/users/addresses/{addressID}", method = RequestMethod.GET)
-    private Collection<User> geUsersLivingAtAddress(@PathVariable (name = "addressID") Long addressID) throws AddressNotFoundException {
+    private Collection<AppUser> geUsersLivingAtAddress(@PathVariable (name = "addressID") Long addressID) throws AddressNotFoundException {
         return userContract.getUsersLivingAtAddress(addressID);
     }
 }