Add email and username to return statement

Testing branch

src/main/java/com/faf223/expensetrackerfaf/controller/UserController.java

@@ -1,8 +1,10 @@
 package com.faf223.expensetrackerfaf.controller;
 
+import com.faf223.expensetrackerfaf.controller.auth.AuthenticationResponse;
 import com.faf223.expensetrackerfaf.controller.auth.ChangePasswordRequest;
 import com.faf223.expensetrackerfaf.dto.UserCreationDTO;
 import com.faf223.expensetrackerfaf.dto.UserDTO;
+import com.faf223.expensetrackerfaf.dto.UserUpdateDTO;
 import com.faf223.expensetrackerfaf.dto.mappers.UserMapper;
 import com.faf223.expensetrackerfaf.model.Credential;
 import com.faf223.expensetrackerfaf.model.User;
@@ -63,6 +65,12 @@ public class UserController {
         return ResponseEntity.status(HttpStatus.OK).build();
     }
 
+    @PatchMapping("/update-user-data")
+    public ResponseEntity<AuthenticationResponse> updateUserData(@RequestBody UserUpdateDTO userUpdateDTO) {
+
+        return ResponseEntity.ok(userService.updateUser(userUpdateDTO));
+    }
+
     @GetMapping("/get-user-data")
     public ResponseEntity<Map<String, String>> getUser() {
         Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
@@ -76,7 +84,8 @@ public class UserController {
                 userData.put("firstname", user.getFirstName());
                 userData.put("lastname", user.getLastName());
                 userData.put("username", user.getUsername());
-                userData.put("userrole", credential.get().getRole().toString()); // Assuming UserRole is an enum
+                userData.put("email", credential.get().getEmail());
+                userData.put("userrole", credential.get().getRole().toString());
 
                 return ResponseEntity.ok(userData);
             }
@@ -86,10 +95,25 @@ public class UserController {
 
     @GetMapping()
     @PreAuthorize("hasRole('ADMIN')")
-    public ResponseEntity<ArrayList<UserDTO>> getAllUsers() {
+    public ResponseEntity<ArrayList<Map<String, String>>> getAllUsers() {
         ArrayList<User> users = new ArrayList<>(userService.getUsers());
 
-        return ResponseEntity.ok(userMapper.toDto(users));
+        ArrayList<Map<String, String>> mappedUsers = new ArrayList<>();
+
+        for (User u: users) {
+            Map<String, String> userData = new HashMap<>();
+            userData.put("firstname", u.getFirstName());
+            userData.put("lastname", u.getLastName());
+            userData.put("username", u.getUsername());
+            Optional<Credential> credential = credentialRepository.findByUser(u);
+            if (credential.isEmpty()) continue;
+            userData.put("email", credential.get().getEmail());
+            userData.put("userrole", credential.get().getRole().toString());
+            mappedUsers.add(userData);
+        }
+
+
+        return ResponseEntity.ok(mappedUsers);
     }
 
     @GetMapping("/delete/{username}")

src/main/java/com/faf223/expensetrackerfaf/dto/UserUpdateDTO.java

@@ -0,0 +1,14 @@
+package com.faf223.expensetrackerfaf.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+public class UserUpdateDTO {
+
+    private String firstname;
+    private String lastname;
+    private String username;
+    private String email;
+}

src/main/java/com/faf223/expensetrackerfaf/model/Credential.java

@@ -2,6 +2,7 @@ package com.faf223.expensetrackerfaf.model;
 
 import jakarta.persistence.*;
 import lombok.AllArgsConstructor;
+import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
@@ -9,6 +10,7 @@ import lombok.NoArgsConstructor;
 @Entity(name = "credentials")
 @NoArgsConstructor
 @AllArgsConstructor
+@Builder
 public class Credential {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)

src/main/java/com/faf223/expensetrackerfaf/model/User.java

@@ -34,8 +34,6 @@
         private String username;
 
         @Transient
-    //    @NotNull(message = "Password must not be null")
-    //    @NotEmpty(message = "Password must not be empty")
         private String password;
 
         @OneToMany(mappedBy = "user", fetch = FetchType.LAZY, cascade = CascadeType.ALL)

src/main/java/com/faf223/expensetrackerfaf/service/UserService.java

@@ -1,12 +1,20 @@
 package com.faf223.expensetrackerfaf.service;
 
+import com.faf223.expensetrackerfaf.config.JwtService;
+import com.faf223.expensetrackerfaf.controller.auth.AuthenticationResponse;
+import com.faf223.expensetrackerfaf.dto.UserUpdateDTO;
 import com.faf223.expensetrackerfaf.model.Credential;
 import com.faf223.expensetrackerfaf.model.Role;
 import com.faf223.expensetrackerfaf.model.User;
 import com.faf223.expensetrackerfaf.repository.CredentialRepository;
 import com.faf223.expensetrackerfaf.repository.UserRepository;
+import com.faf223.expensetrackerfaf.security.PersonDetails;
+import com.faf223.expensetrackerfaf.util.exceptions.UserNotFoundException;
 import jakarta.transaction.Transactional;
 import lombok.RequiredArgsConstructor;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.core.userdetails.UserDetails;
 import org.springframework.stereotype.Service;
 
 import java.util.List;
@@ -18,11 +26,48 @@ public class UserService {
 
     private final UserRepository userRepository;
     private final CredentialRepository credentialRepository;
+    private final JwtService jwtService;
 
     public void updateUser(User user) {
         userRepository.save(user);
     }
 
+    public AuthenticationResponse updateUser(UserUpdateDTO userUpdate) {
+        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+
+        if (authentication != null && authentication.getPrincipal() instanceof UserDetails userDetails) {
+            User user = getUserByEmail(userDetails.getUsername());
+            Optional<Credential> credential = credentialRepository.findByUser(user);
+
+            if (credential.isPresent()) {
+
+                Credential credentialToUpdate = credential.get();
+
+                if (userUpdate.getUsername() != null)
+                    user.setUsername(userUpdate.getUsername());
+                if (userUpdate.getFirstname() != null)
+                    user.setFirstName(userUpdate.getFirstname());
+                if (userUpdate.getLastname() != null)
+                    user.setLastName(userUpdate.getLastname());
+                if (userUpdate.getEmail() != null)
+                    credentialToUpdate.setEmail(userUpdate.getEmail());
+
+                userRepository.save(user);
+                credentialRepository.save(credentialToUpdate);
+
+                UserDetails details = new PersonDetails(credentialToUpdate);
+                String jwtToken = jwtService.generateToken(details);
+                String refreshToken = jwtService.generateRefreshToken(details);
+
+                return AuthenticationResponse.builder()
+                        .accessToken(jwtToken)
+                        .refreshToken(refreshToken)
+                        .build();
+            }
+        }
+        throw new UserNotFoundException("User not found!");
+    }
+
     public List<User> getUsers() {
         return userRepository.findAll();
     }

src/test/java/com/faf223/expensetrackerfaf/repository/CredentialRepositoryTest.java

@@ -0,0 +1,66 @@
+package com.faf223.expensetrackerfaf.repository;
+
+import com.faf223.expensetrackerfaf.model.Credential;
+import com.faf223.expensetrackerfaf.model.User;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@DataJpaTest
+@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
+class CredentialRepositoryTest {
+
+    @Autowired
+    private CredentialRepository credentialRepository;
+
+    @Autowired
+    private UserRepository userRepository;
+    private User user;
+    private Credential credential;
+
+    @BeforeEach
+    void setUp() {
+        user = new User();
+        user.setFirstName("Hamon");
+        user.setLastName("User");
+        user.setUsername("UserHamon");
+
+        credential = Credential.builder()
+                .email("NewEmail@gmail.com")
+                .password("12345")
+                .user(user)
+                .build();
+
+        userRepository.save(user);
+        credentialRepository.save(credential);
+    }
+    @Test
+    void findByEmail() {
+        // when
+        boolean exists = credentialRepository.findByUser(user).isPresent();
+        // then
+        assertThat(exists).isTrue();
+    }
+
+    @Test
+    void itShouldCheckIfCredentialExistsByUser() {
+        // when
+        boolean exists = credentialRepository.findByUser(user).isPresent();
+        // then
+        assertThat(exists).isTrue();
+    }
+
+    @Test
+    void deleteByEmail() {
+        // when
+        credentialRepository.deleteByEmail(credential.getEmail());
+        boolean exists = credentialRepository.findByUser(user).isPresent();
+        // then
+        assertThat(exists).isFalse();
+
+    }
+}

src/test/java/com/faf223/expensetrackerfaf/repository/ExpenseRepositoryTest.java

@@ -2,6 +2,7 @@ package com.faf223.expensetrackerfaf.repository;
 
 import com.faf223.expensetrackerfaf.model.*;
 import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
@@ -13,6 +14,8 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 
+import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat;
+
 @DataJpaTest
 @AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
 public class ExpenseRepositoryTest {
@@ -23,11 +26,12 @@ public class ExpenseRepositoryTest {
     private ExpenseCategoryRepository expenseCategoryRepository;
     @Autowired
     private UserRepository userRepository;
+    private User user;
+    private ExpenseCategory expenseCategory;
 
-    @Test
-    public void ExpenseRepository_SaveAll_ReturnExpense() {
-
-        User user = User.builder()
+    @BeforeEach
+    void setUp() {
+        user = User.builder()
                 .firstName("Test")
                 .lastName("TestLast")
                 .username("UserTest")
@@ -36,7 +40,12 @@ public class ExpenseRepositoryTest {
                 .build();
 
         userRepository.save(user);
-        ExpenseCategory expenseCategory = expenseCategoryRepository.getReferenceById(1L);
+
+        expenseCategory = expenseCategoryRepository.getReferenceById(1L);
+    }
+
+    @Test
+    public void ExpenseRepository_SaveAll_ReturnExpense() {
 
         Expense expense = Expense.builder()
                 .user(user)
@@ -54,17 +63,6 @@ public class ExpenseRepositoryTest {
     @Test
     public void ExpenseRepository_GateAll_ReturnsMoreThenOneExpense() {
 
-        User user = User.builder()
-                .firstName("Test")
-                .lastName("TestLast")
-                .username("UserTest")
-                .incomes(new ArrayList<>())
-                .expenses(new ArrayList<>())
-                .build();
-
-        userRepository.save(user);
-        ExpenseCategory expenseCategory = expenseCategoryRepository.getReferenceById(1L);
-
         List<Expense> expenseList = expenseRepository.findAll();
         int qtyBefore = expenseList.size();
 
@@ -87,23 +85,12 @@ public class ExpenseRepositoryTest {
         expenseList = expenseRepository.findAll();
 
         Assertions.assertThat(expenseList).isNotNull();
-        Assertions.assertThat(expenseList.size()).isEqualTo(qtyBefore + 2);
+        assertThat(expenseList).hasSize(qtyBefore + 2);
     }
 
     @Test
     public void ExpenseRepository_FindById_ReturnExpense() {
 
-        User user = User.builder()
-                .firstName("Test")
-                .lastName("TestLast")
-                .username("UserTest")
-                .incomes(new ArrayList<>())
-                .expenses(new ArrayList<>())
-                .build();
-
-        userRepository.save(user);
-        ExpenseCategory expenseCategory = expenseCategoryRepository.getReferenceById(1L);
-
         Expense expense = Expense.builder()
                 .user(user)
                 .amount(BigDecimal.valueOf(77))
@@ -120,10 +107,7 @@ public class ExpenseRepositoryTest {
     @Test
     public void ExpenseRepository_FindByUser_ReturnExpenses() {
 
-        Optional<User> user = userRepository.findByUsername("Balaban");
-        Assertions.assertThat(user.isPresent()).isTrue();
-
-        List<Expense> expenses = expenseRepository.findByUser(user.get());
+        List<Expense> expenses = expenseRepository.findByUser(user);
 
         Assertions.assertThat(expenses).isNotNull();
     }
@@ -139,12 +123,10 @@ public class ExpenseRepositoryTest {
     @Test
     public void ExpenseRepository_UpdateExpense_ReturnExpenseNotNull() {
 
-        Optional<User> user = userRepository.findByUsername("Deep Deep");
-        Assertions.assertThat(user.isPresent()).isTrue();
         ExpenseCategory expenseCategory = expenseCategoryRepository.getReferenceById(4L);
 
         Expense expense = Expense.builder()
-                .user(user.get())
+                .user(user)
                 .amount(BigDecimal.valueOf(700))
                 .category(expenseCategory)
                 .date(LocalDate.of(2023, 10, 5))
@@ -168,12 +150,10 @@ public class ExpenseRepositoryTest {
     @Test
     public void ExpenseRepository_DeleteExpense_ReturnExpenseNull() {
 
-        Optional<User> user = userRepository.findByUsername("Deep Deep");
-        Assertions.assertThat(user.isPresent()).isTrue();
         ExpenseCategory expenseCategory = expenseCategoryRepository.getReferenceById(4L);
 
         Expense expense = Expense.builder()
-                .user(user.get())
+                .user(user)
                 .amount(BigDecimal.valueOf(700))
                 .category(expenseCategory)
                 .date(LocalDate.of(2023, 10, 5))