update families

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

@@ -98,7 +98,7 @@ public class ExpenseController {
 
     @GetMapping("/personal-expenses")
     @Transactional(readOnly = true)
-    public ResponseEntity<List<ExpenseDTO>> getExpensesByUser(@RequestParam Optional<LocalDate> date,
+    public ResponseEntity<List<ExpenseDTO>> getExpensesByTimeUnits(@RequestParam Optional<LocalDate> date,
                                                               @RequestParam Optional<Integer> month,
                                                               @RequestParam Optional<Integer> startYear,
                                                               @RequestParam Optional<Integer> endYear,

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

@@ -0,0 +1,130 @@
+package com.faf223.expensetrackerfaf.controller;
+
+import com.faf223.expensetrackerfaf.dto.FamilyCreationDTO;
+import com.faf223.expensetrackerfaf.dto.FamilyDTO;
+import com.faf223.expensetrackerfaf.dto.mappers.FamilyMapper;
+import com.faf223.expensetrackerfaf.model.Family;
+import com.faf223.expensetrackerfaf.model.User;
+import com.faf223.expensetrackerfaf.service.FamilyService;
+import com.faf223.expensetrackerfaf.service.UserService;
+import com.faf223.expensetrackerfaf.util.errors.ErrorResponse;
+import com.faf223.expensetrackerfaf.util.exceptions.*;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.validation.BindingResult;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+@RestController
+@RequestMapping("/families")
+@RequiredArgsConstructor
+public class FamilyController {
+
+    private final FamilyService familyService;
+    private final FamilyMapper familyMapper;
+    private final UserService userService;
+
+    @GetMapping()
+    @PreAuthorize("hasRole('ADMIN')")
+    public ResponseEntity<List<FamilyDTO>> getAllFamilies() {
+        List<FamilyDTO> families = familyService.getFamilies().stream().map(familyMapper::toDto).collect(Collectors.toList());
+        if (!families.isEmpty()) return ResponseEntity.ok(families);
+        else throw new FamiliesNotFoundException("Families not found");
+    }
+
+    @PostMapping()
+    public ResponseEntity<Map<String, Long>> createNewFamily(@RequestBody @Valid FamilyCreationDTO familyCreationDTO,
+                                                              BindingResult bindingResult) {
+        if(bindingResult.hasErrors())
+            throw new FamilyNotCreatedException("Could not create new family");
+
+        Family family = familyMapper.toFamily(familyCreationDTO);
+
+        familyService.createOrUpdate(family);
+        Map<String, Long> response = new HashMap<>();
+        response.put("familyId", family.getId());
+        return ResponseEntity.status(HttpStatus.CREATED).body(response);
+    }
+
+    @PatchMapping("/update/{id}")
+    public ResponseEntity<Void> updateFamily(@PathVariable long id, @RequestBody @Valid FamilyCreationDTO familyDTO,
+                                              BindingResult bindingResult) {
+        if(bindingResult.hasErrors())
+            throw new FamilyNotUpdatedException(ErrorResponse.from(bindingResult).getMessage());
+
+        Family family = familyService.getFamilyById(id);
+
+        if(family == null)
+            throw new FamiliesNotFoundException("The family has not been found");
+
+        if(!familyService.containsMember(family))
+            throw new NotAMemberOfTheFamily("You are not a member of this family");
+
+        family.setName(familyDTO.getName());
+
+        familyService.createOrUpdate(family);
+        return ResponseEntity.status(HttpStatus.CREATED).build();
+    }
+
+    @DeleteMapping("/delete/{id}")
+    public void deleteFamily(@PathVariable long id) {
+        familyService.deleteFamilyById(id);
+    }
+
+    @PatchMapping("/add-member/{id}")
+    public ResponseEntity<Void> addFamilyMember(@PathVariable long id, @RequestParam Optional<String> email) {
+        if(email.isEmpty())
+            throw new UserNotFoundException("You have not specified the user email");
+
+        Family family = familyService.getFamilyById(id);
+
+        if(family == null)
+            throw new FamiliesNotFoundException("The family has not been found");
+
+        if(!familyService.containsMember(family))
+            throw new NotAMemberOfTheFamily("You are not a member of this family");
+
+        User user = userService.getUserByEmail(email.get());
+
+        if(user == null)
+            throw new UserNotFoundException("User with the specified email has not been found");
+
+        family.getMembers().add(user);
+
+        familyService.createOrUpdate(family);
+        return ResponseEntity.status(HttpStatus.CREATED).build();
+    }
+
+    @PatchMapping("/remove-member/{id}")
+    public ResponseEntity<Void> removeFamilyMember(@PathVariable long id, @RequestParam Optional<String> email) {
+        if(email.isEmpty())
+            throw new UserNotFoundException("You have not specified the user email");
+
+        Family family = familyService.getFamilyById(id);
+
+        if(family == null)
+            throw new FamiliesNotFoundException("The family has not been found");
+
+        if(!familyService.containsMember(family))
+            throw new NotAMemberOfTheFamily("You are not a member of this family");
+
+        User user = userService.getUserByEmail(email.get());
+
+        if(user == null)
+            throw new UserNotFoundException("User with the specified email has not been found");
+
+        family.getMembers().remove(user);
+
+        familyService.createOrUpdate(family);
+        return ResponseEntity.status(HttpStatus.CREATED).build();
+    }
+
+}

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

@@ -98,7 +98,7 @@ public class IncomeController {
 
     @GetMapping("/personal-incomes")
     @Transactional(readOnly = true)
-    public ResponseEntity<List<IncomeDTO>> getIncomesByUser(@RequestParam Optional<LocalDate> date,
+    public ResponseEntity<List<IncomeDTO>> getIncomesByTimeUnits(@RequestParam Optional<LocalDate> date,
                                                              @RequestParam Optional<Integer> month,
                                                              @RequestParam Optional<Integer> startYear,
                                                              @RequestParam Optional<Integer> endYear,

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

@@ -1,10 +1,8 @@
 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;
@@ -25,10 +23,7 @@ import org.springframework.security.core.userdetails.UserDetails;
 import org.springframework.validation.BindingResult;
 import org.springframework.web.bind.annotation.*;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Optional;
+import java.util.*;
 
 @RestController
 @RequestMapping("/users")
@@ -65,12 +60,6 @@ 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();
@@ -84,8 +73,7 @@ public class UserController {
                 userData.put("firstname", user.getFirstName());
                 userData.put("lastname", user.getLastName());
                 userData.put("username", user.getUsername());
-                userData.put("email", credential.get().getEmail());
-                userData.put("userrole", credential.get().getRole().toString());
+                userData.put("userrole", credential.get().getRole().toString()); // Assuming UserRole is an enum
 
                 return ResponseEntity.ok(userData);
             }
@@ -95,25 +83,10 @@ public class UserController {
 
     @GetMapping()
     @PreAuthorize("hasRole('ADMIN')")
-    public ResponseEntity<ArrayList<Map<String, String>>> getAllUsers() {
+    public ResponseEntity<List<UserDTO>> getAllUsers() {
         ArrayList<User> users = new ArrayList<>(userService.getUsers());
 
-        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);
+        return ResponseEntity.ok(userMapper.toDto(users));
     }
 
     @GetMapping("/delete/{username}")

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

@@ -0,0 +1,14 @@
+package com.faf223.expensetrackerfaf.dto;
+
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+public class FamilyCreationDTO {
+    @NotNull(message = "Name must not be null")
+    @NotEmpty(message = "Name must not be empty")
+    private String name;
+}

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

@@ -0,0 +1,14 @@
+package com.faf223.expensetrackerfaf.dto;
+
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+public class FamilyDTO {
+    @NotNull(message = "Name must not be null")
+    @NotEmpty(message = "Name must not be empty")
+    private String name;
+}

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

@@ -1,14 +0,0 @@
-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/dto/mappers/FamilyMapper.java

@@ -0,0 +1,25 @@
+package com.faf223.expensetrackerfaf.dto.mappers;
+
+import com.faf223.expensetrackerfaf.dto.FamilyCreationDTO;
+import com.faf223.expensetrackerfaf.dto.FamilyDTO;
+import com.faf223.expensetrackerfaf.model.Family;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+@Component
+@RequiredArgsConstructor
+public class FamilyMapper {
+
+    private final UserMapper userMapper;
+
+    public FamilyDTO toDto(Family family) {
+        return new FamilyDTO(family.getId(), family.getName(), userMapper.toDto(family.getMembers()));
+    }
+
+    public Family toFamily(FamilyCreationDTO familyCreationDTO) {
+        Family family = new Family();
+        family.setName(familyCreationDTO.getName());
+        return family;
+    }
+
+}

src/main/java/com/faf223/expensetrackerfaf/dto/mappers/IncomeMapper.java

@@ -2,12 +2,9 @@ package com.faf223.expensetrackerfaf.dto.mappers;
 
 import com.faf223.expensetrackerfaf.dto.IncomeCreationDTO;
 import com.faf223.expensetrackerfaf.dto.IncomeDTO;
-import com.faf223.expensetrackerfaf.model.Expense;
 import com.faf223.expensetrackerfaf.model.Income;
 import com.faf223.expensetrackerfaf.service.IncomeCategoryService;
-import com.faf223.expensetrackerfaf.service.IncomeService;
 import lombok.RequiredArgsConstructor;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
 import java.time.LocalDate;

src/main/java/com/faf223/expensetrackerfaf/dto/mappers/UserMapper.java

@@ -6,6 +6,7 @@ import com.faf223.expensetrackerfaf.model.User;
 import org.springframework.stereotype.Component;
 
 import java.util.ArrayList;
+import java.util.List;
 
 @Component
 public class UserMapper {
@@ -14,11 +15,9 @@ public class UserMapper {
         return new UserDTO(user.getFirstName(), user.getLastName(), user.getUsername());
     }
 
-    public ArrayList<UserDTO> toDto(ArrayList<User> user) {
-
-        ArrayList<UserDTO> list = new ArrayList<>();
-
-        for (User u: user)
+    public List<UserDTO> toDto(List<User> user) {
+        List<UserDTO> list = new ArrayList<>();
+        for (User u : user)
             list.add(toDto(u));
 
         return list;

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

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

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

@@ -38,9 +38,6 @@ public class Expense implements IMoneyTransaction {
     @DecimalMin(value = "0.0", inclusive = false)
     private BigDecimal amount;
 
-    public Expense(LocalDate date, BigDecimal amount) {
-    }
-
     public Expense(ExpenseCategory expenseCategory, LocalDate date, BigDecimal amount) {
         this.category = expenseCategory;
         this.date = date;

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

@@ -0,0 +1,42 @@
+package com.faf223.expensetrackerfaf.model;
+
+import jakarta.persistence.*;
+import jakarta.validation.constraints.NotEmpty;
+import lombok.*;
+
+import java.util.List;
+import java.util.Objects;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Entity(name = "family")
+@Builder
+public class Family {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "family_id")
+    private Long id;
+
+    @NotEmpty
+    @Column(name = "family_name")
+    private String name;
+
+    @OneToMany(mappedBy = "family", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
+    @ToString.Exclude
+    private List<User> members;
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Family family = (Family) o;
+        return Objects.equals(id, family.id) && Objects.equals(name, family.name);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, name);
+    }
+}

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

@@ -1,46 +1,55 @@
-    package com.faf223.expensetrackerfaf.model;
+package com.faf223.expensetrackerfaf.model;
 
-    import jakarta.persistence.*;
-    import jakarta.validation.constraints.NotEmpty;
-    import jakarta.validation.constraints.NotNull;
-    import lombok.*;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import jakarta.persistence.*;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+import lombok.*;
 
-    import java.util.List;
+import java.util.List;
 
-    @Entity(name = "users")
-    @Data
-    @Builder
-    @NoArgsConstructor
-    @AllArgsConstructor
-    public class User {
-        @Id
-        @Column(name = "user_uuid")
-        @GeneratedValue(strategy = GenerationType.UUID)
-        private String userUuid;
+@Entity(name = "users")
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class User {
+    @Id
+    @Column(name = "user_uuid")
+    @GeneratedValue(strategy = GenerationType.UUID)
+    private String userUuid;
 
-        @Column(name = "name")
-        @NotNull(message = "First name must not be null")
-        @NotEmpty(message = "First name must not be empty")
-        private String firstName;
+    @Column(name = "name")
+    @NotNull(message = "First name must not be null")
+    @NotEmpty(message = "First name must not be empty")
+    private String firstName;
 
-        @Column(name = "surname")
-        @NotNull(message = "Last name must not be null")
-        @NotEmpty(message = "Last name must not be empty")
-        private String lastName;
+    @Column(name = "surname")
+    @NotNull(message = "Last name must not be null")
+    @NotEmpty(message = "Last name must not be empty")
+    private String lastName;
 
-        @Column(name = "username")
-        @NotNull(message = "Username must not be null")
-        @NotEmpty(message = "Username must not be empty")
-        private String username;
+    @Column(name = "username")
+    @NotNull(message = "Username must not be null")
+    @NotEmpty(message = "Username must not be empty")
+    private String username;
 
-        @Transient
-        private String password;
+    @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)
-        @ToString.Exclude
-        private List<Expense> expenses;
+    @OneToMany(mappedBy = "user", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
+    @ToString.Exclude
+    private List<Expense> expenses;
 
-        @OneToMany(mappedBy = "user", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
-        @ToString.Exclude
-        private List<Income> incomes;
-    }
+    @OneToMany(mappedBy = "user", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
+    @ToString.Exclude
+    private List<Income> incomes;
+
+    @ManyToOne
+    @JoinColumn(name = "family_id")
+    @ToString.Exclude
+    @JsonIgnore
+    private Family family;
+}

src/main/java/com/faf223/expensetrackerfaf/repository/FamilyRepository.java

@@ -0,0 +1,9 @@
+package com.faf223.expensetrackerfaf.repository;
+
+import com.faf223.expensetrackerfaf.model.Family;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface FamilyRepository extends JpaRepository<Family, Long> {
+}

src/main/java/com/faf223/expensetrackerfaf/repository/IncomeCategoryRepository.java

@@ -6,4 +6,4 @@ import org.springframework.stereotype.Repository;
 
 @Repository
 public interface IncomeCategoryRepository extends JpaRepository<IncomeCategory, Long> {
-}
+}

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

@@ -130,6 +130,8 @@ public class ExpenseService implements ITransactionService {
 
             }
 
+            return true;
+
         }
 
         throw new UserNotAuthenticatedException("You are not authenticated");

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

@@ -0,0 +1,67 @@
+package com.faf223.expensetrackerfaf.service;
+
+import com.faf223.expensetrackerfaf.model.Credential;
+import com.faf223.expensetrackerfaf.model.Family;
+import com.faf223.expensetrackerfaf.model.User;
+import com.faf223.expensetrackerfaf.repository.CredentialRepository;
+import com.faf223.expensetrackerfaf.repository.FamilyRepository;
+import com.faf223.expensetrackerfaf.repository.UserRepository;
+import com.faf223.expensetrackerfaf.util.exceptions.UserNotAuthenticatedException;
+import com.faf223.expensetrackerfaf.util.exceptions.UserNotFoundException;
+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;
+import java.util.Optional;
+
+@Service
+@RequiredArgsConstructor
+public class FamilyService {
+
+    private final FamilyRepository familyRepository;
+    private final CredentialRepository credentialRepository;
+    private final UserRepository userRepository;
+
+    public List<Family> getFamilies() {
+        return familyRepository.findAll();
+    }
+
+    public void createOrUpdate(Family family) {
+        familyRepository.save(family);
+    }
+
+    public Family getFamilyById(long id) {
+        return familyRepository.findById(id).orElse(null);
+    }
+
+    public boolean containsMember(Family family) {
+        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+
+        if (authentication != null && authentication.getPrincipal() instanceof UserDetails userDetails) {
+
+            if(authentication.getAuthorities().stream().noneMatch(authority -> authority.getAuthority().equals("ADMIN"))) {
+
+                Optional<Credential> credential = credentialRepository.findByEmail(userDetails.getUsername());
+                if(credential.isEmpty()) throw new UserNotFoundException("The user has not been found");
+                Optional<User> user = userRepository.findById(credential.get().getUser().getUserUuid());
+                if(user.isEmpty()) throw new UserNotFoundException("The user has not been found");
+
+                return user.get().getFamily().equals(family);
+
+            }
+
+            return true;
+
+        }
+
+        throw new UserNotAuthenticatedException("You are not authenticated");
+    }
+
+    public void deleteFamilyById(long id) {
+        familyRepository.deleteById(id);
+    }
+
+}

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

@@ -129,6 +129,8 @@ public class IncomeService implements ITransactionService {
 
             }
 
+            return true;
+
         }
 
         throw new UserNotAuthenticatedException("You are not authenticated");

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

@@ -1,20 +1,12 @@
 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;
@@ -26,48 +18,11 @@ 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/main/java/com/faf223/expensetrackerfaf/util/exceptions/FamiliesNotFoundException.java

@@ -0,0 +1,9 @@
+package com.faf223.expensetrackerfaf.util.exceptions;
+
+public class FamiliesNotFoundException extends RuntimeException {
+
+    public FamiliesNotFoundException(String message) {
+        super(message);
+    }
+
+}

src/main/java/com/faf223/expensetrackerfaf/util/exceptions/FamilyNotCreatedException.java

@@ -0,0 +1,9 @@
+package com.faf223.expensetrackerfaf.util.exceptions;
+
+public class FamilyNotCreatedException extends RuntimeException {
+
+    public FamilyNotCreatedException(String message) {
+        super(message);
+    }
+
+}

src/main/java/com/faf223/expensetrackerfaf/util/exceptions/FamilyNotUpdatedException.java

@@ -0,0 +1,9 @@
+package com.faf223.expensetrackerfaf.util.exceptions;
+
+public class FamilyNotUpdatedException extends RuntimeException {
+
+    public FamilyNotUpdatedException(String message) {
+        super(message);
+    }
+
+}

src/main/java/com/faf223/expensetrackerfaf/util/exceptions/NotAMemberOfTheFamily.java

@@ -0,0 +1,9 @@
+package com.faf223.expensetrackerfaf.util.exceptions;
+
+public class NotAMemberOfTheFamily extends RuntimeException {
+
+    public NotAMemberOfTheFamily(String message) {
+        super(message);
+    }
+
+}

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

@@ -1,66 +0,0 @@
-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,7 +2,6 @@ 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;
@@ -14,8 +13,6 @@ 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 {
@@ -26,12 +23,11 @@ public class ExpenseRepositoryTest {
     private ExpenseCategoryRepository expenseCategoryRepository;
     @Autowired
     private UserRepository userRepository;
-    private User user;
-    private ExpenseCategory expenseCategory;
 
-    @BeforeEach
-    void setUp() {
-        user = User.builder()
+    @Test
+    public void ExpenseRepository_SaveAll_ReturnExpense() {
+
+        User user = User.builder()
                 .firstName("Test")
                 .lastName("TestLast")
                 .username("UserTest")
@@ -40,12 +36,7 @@ public class ExpenseRepositoryTest {
                 .build();
 
         userRepository.save(user);
-
-        expenseCategory = expenseCategoryRepository.getReferenceById(1L);
-    }
-
-    @Test
-    public void ExpenseRepository_SaveAll_ReturnExpense() {
+        ExpenseCategory expenseCategory = expenseCategoryRepository.getReferenceById(1L);
 
         Expense expense = Expense.builder()
                 .user(user)
@@ -63,6 +54,17 @@ 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();
 
@@ -85,12 +87,23 @@ public class ExpenseRepositoryTest {
         expenseList = expenseRepository.findAll();
 
         Assertions.assertThat(expenseList).isNotNull();
-        assertThat(expenseList).hasSize(qtyBefore + 2);
+        Assertions.assertThat(expenseList.size()).isEqualTo(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))
@@ -107,7 +120,10 @@ public class ExpenseRepositoryTest {
     @Test
     public void ExpenseRepository_FindByUser_ReturnExpenses() {
 
-        List<Expense> expenses = expenseRepository.findByUser(user);
+        Optional<User> user = userRepository.findByUsername("Balaban");
+        Assertions.assertThat(user.isPresent()).isTrue();
+
+        List<Expense> expenses = expenseRepository.findByUser(user.get());
 
         Assertions.assertThat(expenses).isNotNull();
     }
@@ -123,10 +139,12 @@ 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)
+                .user(user.get())
                 .amount(BigDecimal.valueOf(700))
                 .category(expenseCategory)
                 .date(LocalDate.of(2023, 10, 5))
@@ -150,10 +168,12 @@ 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)
+                .user(user.get())
                 .amount(BigDecimal.valueOf(700))
                 .category(expenseCategory)
                 .date(LocalDate.of(2023, 10, 5))