Index: backend/.gitignore =================================================================== --- backend/.gitignore (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ backend/.gitignore (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -4,4 +4,7 @@ !**/src/main/**/target/ !**/src/test/**/target/ + +/src/main/resources/application-dev.properties +/src/main/resources/application-test.properties ### IntelliJ IDEA ### Index: backend/mvnw.cmd =================================================================== --- backend/mvnw.cmd (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ backend/mvnw.cmd (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -24,5 +24,5 @@ @REM Optional ENV vars @REM MVNW_REPOURL - repo url base for downloading maven distribution -@REM MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven +@REM MVNW_USERNAME/MVNW_PASSWORD - account and password for downloading maven @REM MVNW_VERBOSE - true: enable verbose log; others: silence the output @REM ---------------------------------------------------------------------------- Index: backend/pom.xml =================================================================== --- backend/pom.xml (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ backend/pom.xml (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -6,5 +6,5 @@ org.springframework.boot spring-boot-starter-parent - 3.5.0 + 3.5.3 @@ -19,5 +19,8 @@ - + + borjan + Borjan Gjorgjievski + @@ -30,9 +33,33 @@ 17 + + org.springframework.boot spring-boot-starter-web + + org.springframework.boot + spring-boot-starter-data-jpa + + + org.springframework.boot + spring-boot-starter-security + + + org.springframework.boot + spring-boot-starter-validation + + + + + org.postgresql + postgresql + 42.7.7 + runtime + + + org.projectlombok @@ -41,13 +68,6 @@ provided - - org.springframework.boot - spring-boot-starter-test - test - - - org.springframework.boot - spring-boot-starter-data-jpa - + + org.mapstruct @@ -61,14 +81,19 @@ provided + + - org.postgresql - postgresql - 42.7.7 - runtime + io.jsonwebtoken + jjwt + 0.9.1 + + org.springframework.boot - spring-boot-starter-security + spring-boot-starter-test + test + org.springframework.security Index: backend/src/main/java/com/shifterwebapp/shifter/AppConfig.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/AppConfig.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) +++ backend/src/main/java/com/shifterwebapp/shifter/AppConfig.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -0,0 +1,67 @@ +package com.shifterwebapp.shifter; + +import com.shifterwebapp.shifter.auth.CustomUserDetailsService; +import lombok.RequiredArgsConstructor; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.security.authentication.AuthenticationManager; +import org.springframework.security.authentication.AuthenticationProvider; +import org.springframework.security.authentication.dao.DaoAuthenticationProvider; +import org.springframework.security.config.Customizer; +import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder; +import org.springframework.security.config.annotation.web.builders.HttpSecurity; +import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity; +import org.springframework.security.config.http.SessionCreationPolicy; +import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder; +import org.springframework.security.crypto.password.NoOpPasswordEncoder; +import org.springframework.security.crypto.password.PasswordEncoder; +import org.springframework.security.web.SecurityFilterChain; +import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer; + + +@Configuration +@EnableWebSecurity +@RequiredArgsConstructor +public class AppConfig { + + private final CustomUserDetailsService userDetailsService; + + @Bean + public PasswordEncoder passwordEncoder() { + return new BCryptPasswordEncoder(12); + } + + @Bean + public AuthenticationProvider authenticationProvider() { + DaoAuthenticationProvider provider = new DaoAuthenticationProvider(); + provider.setUserDetailsService(userDetailsService); + provider.setPasswordEncoder(passwordEncoder()); + return provider; + } + + @Bean + public AuthenticationManager authenticationManager(HttpSecurity http) throws Exception { + return http.getSharedObject(AuthenticationManagerBuilder.class) + .authenticationProvider(authenticationProvider()) + .build(); + } + + @Bean + public SecurityFilterChain filterChain(HttpSecurity http) throws Exception { + http + .csrf(csrf -> csrf.disable()) + .sessionManagement(session -> session + .sessionCreationPolicy(SessionCreationPolicy.STATELESS) + ) + .authorizeHttpRequests(request -> request + .requestMatchers("/api/auth/**").permitAll() + .anyRequest().authenticated() + ) +// .formLogin(AbstractHttpConfigurer::disable) + .httpBasic(Customizer.withDefaults()) + .logout(AbstractHttpConfigurer::disable); + + return http.build(); + } + +} Index: backend/src/main/java/com/shifterwebapp/shifter/ShifterApplication.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/ShifterApplication.java (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ backend/src/main/java/com/shifterwebapp/shifter/ShifterApplication.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -3,4 +3,5 @@ import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder; @SpringBootApplication Index: backend/src/main/java/com/shifterwebapp/shifter/Validate.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/Validate.java (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ backend/src/main/java/com/shifterwebapp/shifter/Validate.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -4,5 +4,5 @@ import com.shifterwebapp.shifter.exception.ResourceNotFoundException; import com.shifterwebapp.shifter.payment.PaymentRepository; -import com.shifterwebapp.shifter.user.UserRepository; +import com.shifterwebapp.shifter.account.AccountRepository; import lombok.RequiredArgsConstructor; import org.springframework.stereotype.Component; @@ -12,10 +12,10 @@ public class Validate { - private final UserRepository userRepository; + private final AccountRepository accountRepository; private final CourseRepository courseRepository; private final PaymentRepository paymentRepository; - public void validateUserExists(Long userId) { - if (!userRepository.existsById(userId)) { + public void validateAccountExists(Long userId) { + if (!accountRepository.existsById(userId)) { throw new ResourceNotFoundException("User with ID " + userId + " not found!"); } Index: backend/src/main/java/com/shifterwebapp/shifter/account/Account.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/account/Account.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) +++ backend/src/main/java/com/shifterwebapp/shifter/account/Account.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -0,0 +1,58 @@ +package com.shifterwebapp.shifter.account; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.shifterwebapp.shifter.payment.Payment; +import com.shifterwebapp.shifter.enums.CompanyType; +import com.shifterwebapp.shifter.enums.Interests; +import com.shifterwebapp.shifter.enums.Skills; +import jakarta.persistence.*; +import lombok.*; + +import java.util.List; + +@Getter +@Setter +@NoArgsConstructor +@AllArgsConstructor +@Builder +@Entity +public class Account { + @Id + @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "account_seq") + @SequenceGenerator(name = "account_seq", sequenceName = "account_sequence", allocationSize = 1) + private Long id; + + private String name; + + private String email; + + @JsonIgnore + private String passwordHash; // SHOULD I USE JSON IGNORE HERE? OR IS IT ENOUGH TO NOT EXPOSE IT IN DTO? + + private Boolean isAdmin; + + private CompanyType companyType; + + private String workPosition; + + @ElementCollection(targetClass = Interests.class) + @Enumerated(EnumType.STRING) + private List interests; + + @ElementCollection(targetClass = Skills.class) + @Enumerated(EnumType.STRING) + private List skills; + + @ElementCollection(targetClass = Skills.class) + @Enumerated(EnumType.STRING) + private List skillGap; + + private Integer points; + + @ElementCollection + private List favoriteCourses; + + @OneToMany(mappedBy = "account", cascade = CascadeType.PERSIST, orphanRemoval = true) + private List payments; // WHEN DELETING account SET PAYMENTS TO NULL, BECAUSE PAYMENTS DONT GET DELETED +} + Index: backend/src/main/java/com/shifterwebapp/shifter/account/AccountController.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/account/AccountController.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) +++ backend/src/main/java/com/shifterwebapp/shifter/account/AccountController.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -0,0 +1,107 @@ +package com.shifterwebapp.shifter.account; + +import com.shifterwebapp.shifter.enums.CompanyType; +import com.shifterwebapp.shifter.enums.Interests; +import com.shifterwebapp.shifter.enums.Skills; +import com.shifterwebapp.shifter.account.service.AccountService; +import lombok.RequiredArgsConstructor; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +@RequiredArgsConstructor +@RestController +@RequestMapping("${api.base.path}/account") +public class AccountController { + + private final AccountService accountService; + + @GetMapping("/{accountId}") + public ResponseEntity getAccount(@PathVariable Long accountId) { + AccountDto accountDto = accountService.getAccountById(accountId); + return ResponseEntity.ok(accountDto); + } + + @DeleteMapping("/{accountId}") + public ResponseEntity deleteAccount(@PathVariable Long accountId) { + accountService.deleteAccount(accountId); + return ResponseEntity.noContent().build(); + } + + @PutMapping("/{accountId}/name") + public ResponseEntity updateName(@PathVariable Long accountId, @RequestParam String newName) { + AccountDto accountDto = accountService.updateName(accountId, newName); + return ResponseEntity.ok(accountDto); + } + + @PutMapping("/{accountId}/mail") + public ResponseEntity updateMail(@PathVariable Long accountId, @RequestParam String newMail) { + AccountDto accountDto = accountService.updateMail(accountId, newMail); + return ResponseEntity.ok(accountDto); + } + + @PutMapping("/{accountId}/password") + public ResponseEntity updatePassword(@PathVariable Long accountId, @RequestParam String newPassword) { + AccountDto accountDto = accountService.updatePassword(accountId, newPassword); + return ResponseEntity.ok(accountDto); + } + + @PutMapping("/{accountId}/work-position") + public ResponseEntity updateWorkPosition(@PathVariable Long accountId, @RequestParam String newWorkPosition) { + AccountDto accountDto = accountService.updateWorkPosition(accountId, newWorkPosition); + return ResponseEntity.ok(accountDto); + } + + @PutMapping("/{accountId}/company-type") + public ResponseEntity updateCompanyType(@PathVariable Long accountId, @RequestParam CompanyType newCompanyType) { + AccountDto accountDto = accountService.updateCompanyType(accountId, newCompanyType); + return ResponseEntity.ok(accountDto); + } + + @PutMapping("/{accountId}/add/interest") + public ResponseEntity addInterest(@PathVariable Long accountId, @RequestParam Interests newInterest) { + AccountDto accountDto = accountService.addInterest(accountId, newInterest); + return ResponseEntity.ok(accountDto); + } + + @PutMapping("/{accountId}/add/skill") + public ResponseEntity addSkill(@PathVariable Long accountId, @RequestParam Skills newSkill) { + AccountDto accountDto = accountService.addSkill(accountId, newSkill); + return ResponseEntity.ok(accountDto); + } + + @PutMapping("/{accountId}/add/skill-gap") + public ResponseEntity addSkillGap(@PathVariable Long accountId, @RequestParam Skills newSkillGap) { + AccountDto accountDto = accountService.addSkillGap(accountId, newSkillGap); + return ResponseEntity.ok(accountDto); + } + + @PutMapping("/{accountId}/add/favorite-course") + public ResponseEntity addFavoriteCourse(@PathVariable Long accountId, @RequestParam Integer newFavoriteCourse) { + AccountDto accountDto = accountService.addFavoriteCourse(accountId, newFavoriteCourse); + return ResponseEntity.ok(accountDto); + } + + @PutMapping("/{accountId}/remove/interest") + public ResponseEntity removeInterest(@PathVariable Long accountId, @RequestParam Interests oldInterest) { + AccountDto accountDto = accountService.removeInterest(accountId, oldInterest); + return ResponseEntity.ok(accountDto); + } + + @PutMapping("/{accountId}/remove/skill") + public ResponseEntity removeSkill(@PathVariable Long accountId, @RequestParam Skills oldSkill) { + AccountDto accountDto = accountService.removeSkill(accountId, oldSkill); + return ResponseEntity.ok(accountDto); + } + + @PutMapping("/{accountId}/remove/skill-gap") + public ResponseEntity removeSkillGap(@PathVariable Long accountId, @RequestParam Skills oldSkillGap) { + AccountDto accountDto = accountService.removeSkillGap(accountId, oldSkillGap); + return ResponseEntity.ok(accountDto); + } + + @PutMapping("/{accountId}/remove/favorite-course") + public ResponseEntity removeFavoriteCourse(@PathVariable Long accountId, @RequestParam Integer oldFavoriteCourse) { + AccountDto accountDto = accountService.removeFavoriteCourse(accountId, oldFavoriteCourse); + return ResponseEntity.ok(accountDto); + } +} Index: backend/src/main/java/com/shifterwebapp/shifter/account/AccountDto.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/account/AccountDto.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) +++ backend/src/main/java/com/shifterwebapp/shifter/account/AccountDto.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -0,0 +1,44 @@ +package com.shifterwebapp.shifter.account; + +import com.shifterwebapp.shifter.payment.PaymentDto; +import com.shifterwebapp.shifter.enums.CompanyType; +import com.shifterwebapp.shifter.enums.Interests; +import com.shifterwebapp.shifter.enums.Skills; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.util.List; + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class AccountDto { + + private Long id; + + private String email; + + private String password; + + private String name; + + private CompanyType companyType; + + private String workPosition; + + private List interests; + + private List skills; + + private List skillGap; + + private Integer points; + + private List favoriteCourses; + + private List payments; +} + + + Index: backend/src/main/java/com/shifterwebapp/shifter/account/AccountMapper.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/account/AccountMapper.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) +++ backend/src/main/java/com/shifterwebapp/shifter/account/AccountMapper.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -0,0 +1,18 @@ +package com.shifterwebapp.shifter.account; + +import org.mapstruct.InheritInverseConfiguration; +import org.mapstruct.Mapper; + +import java.util.List; + +@Mapper(componentModel = "spring") +public interface AccountMapper { + + AccountDto toDto(Account account); + List toDto(List accounts); + + @InheritInverseConfiguration + Account toEntity(AccountDto accountDto); + @InheritInverseConfiguration + List toEntity(List accountDtos); +} Index: backend/src/main/java/com/shifterwebapp/shifter/account/AccountRepository.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/account/AccountRepository.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) +++ backend/src/main/java/com/shifterwebapp/shifter/account/AccountRepository.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -0,0 +1,12 @@ +package com.shifterwebapp.shifter.account; + +import org.springframework.data.jpa.repository.JpaRepository; + +import java.util.Optional; + +public interface AccountRepository extends JpaRepository { + + boolean existsAccountByEmail(String email); + + Optional findByEmail(String email); +} Index: backend/src/main/java/com/shifterwebapp/shifter/account/service/AccountService.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/account/service/AccountService.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) +++ backend/src/main/java/com/shifterwebapp/shifter/account/service/AccountService.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -0,0 +1,267 @@ +package com.shifterwebapp.shifter.account.service; + +import com.shifterwebapp.shifter.Validate; +import com.shifterwebapp.shifter.auth.RegisterDto; +import com.shifterwebapp.shifter.enums.CompanyType; +import com.shifterwebapp.shifter.enums.Interests; +import com.shifterwebapp.shifter.enums.Skills; +import com.shifterwebapp.shifter.payment.Payment; +import com.shifterwebapp.shifter.account.*; +import lombok.RequiredArgsConstructor; +import org.springframework.security.crypto.password.PasswordEncoder; +import org.springframework.stereotype.Service; + +import java.util.List; + +@Service +@RequiredArgsConstructor +public class AccountService implements ImplAccountService { + + private final AccountRepository accountRepository; + private final AccountMapper accountMapper; + private final Validate validate; + private final PasswordEncoder passwordEncoder; + + @Override + public List getAllAccounts() { + List accounts = accountRepository.findAll(); + return accountMapper.toDto(accounts); + } + + @Override + public AccountDto getAccountById(Long accountId) { + validate.validateAccountExists(accountId); + Account account = accountRepository.findById(accountId).orElseThrow(); + return accountMapper.toDto(account); + } + + @Override + public void createAccount(RegisterDto registerDto) { + if (accountRepository.existsAccountByEmail(registerDto.getEmail())) { + throw new RuntimeException("Email already in use"); + } + + Account account = Account.builder() + .name(registerDto.getName()) + .email(registerDto.getEmail()) + .passwordHash(passwordEncoder.encode(registerDto.getPassword())) + .isAdmin(false) + .companyType(registerDto.getCompanyType()) + .workPosition(registerDto.getWorkPosition()) + .interests(registerDto.getInterests()) + .skills(registerDto.getSkills()) + .skillGap(registerDto.getSkillGap()) + .points(0) + .favoriteCourses(List.of()) + .build(); + + accountRepository.save(account); + } + + @Override + public void deleteAccount(Long accountId) { + validate.validateAccountExists(accountId); + accountRepository.deleteById(accountId); + } + + @Override + public AccountDto updateName(Long accountId, String newName) { + validate.validateAccountExists(accountId); + Account account = accountRepository.findById(accountId).orElseThrow(); + account.setName(newName); + accountRepository.save(account); + return accountMapper.toDto(account); + } + + @Override + public AccountDto updateMail(Long accountId, String newMail) { + validate.validateAccountExists(accountId); + Account account = accountRepository.findById(accountId).orElseThrow(); + account.setEmail(newMail); + accountRepository.save(account); + return accountMapper.toDto(account); + } + + @Override + public AccountDto updatePassword(Long accountId, String newPass) { + validate.validateAccountExists(accountId); + Account account = accountRepository.findById(accountId).orElseThrow(); + account.setPasswordHash(passwordEncoder.encode(newPass)); + accountRepository.save(account); + return accountMapper.toDto(account); + } + + @Override + public AccountDto updateWorkPosition(Long accountId, String newWorkPosition) { + validate.validateAccountExists(accountId); + Account account = accountRepository.findById(accountId).orElseThrow(); + account.setWorkPosition(newWorkPosition); + accountRepository.save(account); + return accountMapper.toDto(account); + } + + @Override + public AccountDto updateCompanyType(Long accountId, CompanyType newCompanyType) { + validate.validateAccountExists(accountId); + Account account = accountRepository.findById(accountId).orElseThrow(); + account.setCompanyType(newCompanyType); + accountRepository.save(account); + return accountMapper.toDto(account); + } + + @Override + public AccountDto addInterest(Long accountId, Interests newInterest) { + validate.validateAccountExists(accountId); + Account account = accountRepository.findById(accountId).orElseThrow(); + if (!account.getInterests().contains(newInterest)) { + account.getInterests().add(newInterest); + } + accountRepository.save(account); + return accountMapper.toDto(account); + } + + @Override + public AccountDto addSkill(Long accountId, Skills newSkill) { + validate.validateAccountExists(accountId); + Account account = accountRepository.findById(accountId).orElseThrow(); + if (!account.getSkills().contains(newSkill)) { + account.getSkills().add(newSkill); + } + accountRepository.save(account); + return accountMapper.toDto(account); + } + + @Override + public AccountDto addSkills(Long accountId, List newSkills) { + validate.validateAccountExists(accountId); + Account account = accountRepository.findById(accountId).orElseThrow(); + for (Skills skill : newSkills) { + if (!account.getSkills().contains(skill)) { + account.getSkills().add(skill); + } + } + accountRepository.save(account); + return accountMapper.toDto(account); + } + + @Override + public AccountDto addSkillGap(Long accountId, Skills newSkillGap) { + validate.validateAccountExists(accountId); + Account account = accountRepository.findById(accountId).orElseThrow(); + if (!account.getSkillGap().contains(newSkillGap)) { + account.getSkillGap().add(newSkillGap); + } + accountRepository.save(account); + return accountMapper.toDto(account); + } + + @Override + public AccountDto addFavoriteCourse(Long accountId, Integer newFavoriteCourseId) { + validate.validateAccountExists(accountId); + Account account = accountRepository.findById(accountId).orElseThrow(); + if (!account.getFavoriteCourses().contains(newFavoriteCourseId)) { + account.getFavoriteCourses().add(newFavoriteCourseId); + } + accountRepository.save(account); + return accountMapper.toDto(account); + } + + @Override + public AccountDto addPoints(Long accountId, Integer newPointsAchieved) { + validate.validateAccountExists(accountId); + Account account = accountRepository.findById(accountId).orElseThrow(); + Integer newPoints = account.getPoints() + newPointsAchieved; + account.setPoints(newPoints); + accountRepository.save(account); + return accountMapper.toDto(account); + } + + @Override + public AccountDto addPayment(Long accountId, Payment newPayment) { + validate.validateAccountExists(accountId); + Account account = accountRepository.findById(accountId).orElseThrow(); + if (!account.getPayments().contains(newPayment)) { + account.getPayments().add(newPayment); + } + accountRepository.save(account); + return accountMapper.toDto(account); + } + + @Override + public AccountDto removeInterest(Long accountId, Interests removeInterest) { + validate.validateAccountExists(accountId); + Account account = accountRepository.findById(accountId).orElseThrow(); + if (!account.getInterests().contains(removeInterest)) { + account.getInterests().remove(removeInterest); + } + accountRepository.save(account); + return accountMapper.toDto(account); + } + + @Override + public AccountDto removeSkill(Long accountId, Skills removeSkill) { + validate.validateAccountExists(accountId); + Account account = accountRepository.findById(accountId).orElseThrow(); + if (!account.getSkills().contains(removeSkill)) { + account.getSkills().remove(removeSkill); + } + accountRepository.save(account); + return accountMapper.toDto(account); + } + + @Override + public AccountDto removeSkillGap(Long accountId, Skills removeSkillGap) { + validate.validateAccountExists(accountId); + Account account = accountRepository.findById(accountId).orElseThrow(); + if (!account.getSkillGap().contains(removeSkillGap)) { + account.getSkillGap().remove(removeSkillGap); + } + accountRepository.save(account); + return accountMapper.toDto(account); + } + + @Override + public AccountDto removeSkillGaps(Long accountId, List removeSkillGaps) { + validate.validateAccountExists(accountId); + Account account = accountRepository.findById(accountId).orElseThrow(); + for (Skills skill : removeSkillGaps) { + if (!account.getSkillGap().contains(skill)) { + account.getSkillGap().remove(skill); + } + } + accountRepository.save(account); + return accountMapper.toDto(account); + } + + @Override + public AccountDto removeFavoriteCourse(Long accountId, Integer removeFavoriteCourseId) { + validate.validateAccountExists(accountId); + Account account = accountRepository.findById(accountId).orElseThrow(); + if (!account.getFavoriteCourses().contains(removeFavoriteCourseId)) { + account.getFavoriteCourses().remove(removeFavoriteCourseId); + } + accountRepository.save(account); + return accountMapper.toDto(account); + } + + @Override + public AccountDto removePoints(Long accountId, Integer removePointsAchieved) { + validate.validateAccountExists(accountId); + Account account = accountRepository.findById(accountId).orElseThrow(); + Integer newPoints = account.getPoints() - removePointsAchieved; + account.setPoints(newPoints); + accountRepository.save(account); + return accountMapper.toDto(account); + } + + @Override + public AccountDto removePayment(Long accountId, Payment removePayment) { + validate.validateAccountExists(accountId); + Account account = accountRepository.findById(accountId).orElseThrow(); + if (!account.getPayments().contains(removePayment)) { + account.getPayments().remove(removePayment); + } + accountRepository.save(account); + return accountMapper.toDto(account); + } +} Index: backend/src/main/java/com/shifterwebapp/shifter/account/service/ImplAccountService.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/account/service/ImplAccountService.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) +++ backend/src/main/java/com/shifterwebapp/shifter/account/service/ImplAccountService.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -0,0 +1,41 @@ +package com.shifterwebapp.shifter.account.service; + +import com.shifterwebapp.shifter.auth.RegisterDto; +import com.shifterwebapp.shifter.payment.Payment; +import com.shifterwebapp.shifter.account.AccountDto; +import com.shifterwebapp.shifter.enums.CompanyType; +import com.shifterwebapp.shifter.enums.Interests; +import com.shifterwebapp.shifter.enums.Skills; + +import java.util.List; + +public interface ImplAccountService { + List getAllAccounts(); + AccountDto getAccountById(Long id); + + void createAccount(RegisterDto registerDto); + void deleteAccount(Long id); + + AccountDto updateName(Long id, String newName); + AccountDto updateMail(Long id, String newMail); + AccountDto updatePassword(Long id, String newPassHash); + AccountDto updateWorkPosition(Long id, String newWorkPosition); + AccountDto updateCompanyType(Long id, CompanyType newCompanyType); + + AccountDto addInterest(Long id, Interests newInterest); + AccountDto addSkill(Long id, Skills newSkill); + AccountDto addSkills(Long id, List newSkills); + AccountDto addSkillGap(Long id, Skills newSkillGap); + AccountDto addFavoriteCourse(Long id, Integer newFavoriteCourseId); + AccountDto addPoints(Long id, Integer newPointsAchieved); + AccountDto addPayment(Long id, Payment newPayment); + + AccountDto removeInterest(Long id, Interests removeInterest); + AccountDto removeSkill(Long id, Skills removeSkill); + AccountDto removeSkillGap(Long id, Skills removeSkillGap); + AccountDto removeSkillGaps(Long id, List removeSkillGaps); + AccountDto removeFavoriteCourse(Long id, Integer removeFavoriteCourseId); + AccountDto removePoints(Long id, Integer removePointsAchieved); + AccountDto removePayment(Long id, Payment removePayment); + +} Index: backend/src/main/java/com/shifterwebapp/shifter/auth/AuthController.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/auth/AuthController.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) +++ backend/src/main/java/com/shifterwebapp/shifter/auth/AuthController.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -0,0 +1,27 @@ +package com.shifterwebapp.shifter.auth; + +import com.shifterwebapp.shifter.account.service.AccountService; +import jakarta.validation.Valid; +import lombok.RequiredArgsConstructor; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +@RequiredArgsConstructor +@RestController +@RequestMapping("${api.base.path}/auth") +public class AuthController { + + private final AccountService accountService; + + @PostMapping("/register") + public ResponseEntity register(@Valid @RequestBody RegisterDto request) { + accountService.createAccount(request); + return ResponseEntity.ok("User registered successfully"); + } + + @PostMapping("/delete") + public ResponseEntity deleteAll(@RequestParam Long accountId) { + accountService.deleteAccount(accountId); + return ResponseEntity.ok("User registered successfully"); + } +} Index: backend/src/main/java/com/shifterwebapp/shifter/auth/AuthService.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/auth/AuthService.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) +++ backend/src/main/java/com/shifterwebapp/shifter/auth/AuthService.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -0,0 +1,14 @@ +package com.shifterwebapp.shifter.auth; + +import com.shifterwebapp.shifter.account.AccountRepository; +import lombok.RequiredArgsConstructor; +import org.springframework.security.crypto.password.PasswordEncoder; +import org.springframework.stereotype.Service; + +@Service +@RequiredArgsConstructor +public class AuthService { + private final AccountRepository accountRepository; + private final PasswordEncoder passwordEncoder; + +} Index: backend/src/main/java/com/shifterwebapp/shifter/auth/CustomUserDetails.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/auth/CustomUserDetails.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) +++ backend/src/main/java/com/shifterwebapp/shifter/auth/CustomUserDetails.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -0,0 +1,53 @@ +package com.shifterwebapp.shifter.auth; + +import com.shifterwebapp.shifter.account.Account; +import org.springframework.security.core.GrantedAuthority; +import org.springframework.security.core.authority.SimpleGrantedAuthority; +import org.springframework.security.core.userdetails.UserDetails; +import java.util.Collection; +import java.util.List; + +public class CustomUserDetails implements UserDetails { + + private final Account account; + + public CustomUserDetails(Account account) { + this.account = account; + } + + @Override + public Collection getAuthorities() { + // Example: give ROLE_ADMIN if user.isAdmin() else ROLE_USER + return account.getIsAdmin() + ? List.of(new SimpleGrantedAuthority("ROLE_ADMIN")) + : List.of(new SimpleGrantedAuthority("ROLE_USER")); + } + + @Override + public String getPassword() { + return account.getPasswordHash(); + } + + @Override + public String getUsername() { + return account.getEmail(); + } + + // You can implement these as you prefer + @Override + public boolean isAccountNonExpired() { + return true; + } + @Override + public boolean isAccountNonLocked() { + return true; + } + @Override + public boolean isCredentialsNonExpired() { + return true; + } + @Override + public boolean isEnabled() { + return true; + } +} Index: backend/src/main/java/com/shifterwebapp/shifter/auth/CustomUserDetailsService.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/auth/CustomUserDetailsService.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) +++ backend/src/main/java/com/shifterwebapp/shifter/auth/CustomUserDetailsService.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -0,0 +1,23 @@ +package com.shifterwebapp.shifter.auth; + +import com.shifterwebapp.shifter.account.Account; +import com.shifterwebapp.shifter.account.AccountRepository; +import lombok.RequiredArgsConstructor; +import org.springframework.security.core.userdetails.UserDetails; +import org.springframework.security.core.userdetails.UserDetailsService; +import org.springframework.security.core.userdetails.UsernameNotFoundException; +import org.springframework.stereotype.Service; + +@Service +@RequiredArgsConstructor +public class CustomUserDetailsService implements UserDetailsService { + + private final AccountRepository accountRepository; + + @Override + public UserDetails loadUserByUsername(String email) throws UsernameNotFoundException { + Account account = accountRepository.findByEmail(email) + .orElseThrow(() -> new UsernameNotFoundException("User not found with email: " + email)); + return new CustomUserDetails(account); + } +} Index: backend/src/main/java/com/shifterwebapp/shifter/auth/HelloController.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/auth/HelloController.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) +++ backend/src/main/java/com/shifterwebapp/shifter/auth/HelloController.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -0,0 +1,12 @@ +package com.shifterwebapp.shifter.auth; + +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.RestController; + +@RestController +public class HelloController { + @GetMapping("/") + public String sayHello() { + return "Hello, World!"; + } +} Index: backend/src/main/java/com/shifterwebapp/shifter/auth/RegisterDto.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/auth/RegisterDto.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) +++ backend/src/main/java/com/shifterwebapp/shifter/auth/RegisterDto.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -0,0 +1,34 @@ +package com.shifterwebapp.shifter.auth; + +import com.shifterwebapp.shifter.enums.CompanyType; +import com.shifterwebapp.shifter.enums.Interests; +import com.shifterwebapp.shifter.enums.Skills; +import jakarta.validation.constraints.Email; +import jakarta.validation.constraints.NotBlank; +import lombok.Data; + +import java.util.List; + +@Data +public class RegisterDto { + + @Email + @NotBlank + private String email; + + @NotBlank + private String password; + + @NotBlank + private String name; + + private CompanyType companyType; + + private String workPosition; + + private List interests; + + private List skills; + + private List skillGap; +} Index: backend/src/main/java/com/shifterwebapp/shifter/enrollment/EnrollmentRepository.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/enrollment/EnrollmentRepository.java (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ backend/src/main/java/com/shifterwebapp/shifter/enrollment/EnrollmentRepository.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -9,6 +9,6 @@ public interface EnrollmentRepository extends JpaRepository { - @Query("select e from Enrollment e where e.payment.user.id = :userId") - List findEnrollmentsByUser(@Param("userId") Long userId); + @Query("select e from Enrollment e where e.payment.account.id = :accountId") + List findEnrollmentsByAccount(@Param("accountId") Long accountId); @Query("select e from Enrollment e where e.course.id = :courseId") @@ -16,8 +16,8 @@ @Query("select case when count(e) > 0 then true else false end" + - " from Enrollment e where e.payment.user.id = :userId and e.course.id = :courseId") - Boolean findIsUserEnrolledInCourse(@Param("userId") Long userId, @Param("courseId") Long courseId); + " from Enrollment e where e.payment.account.id = :accountId and e.course.id = :courseId") + Boolean findIsAccountEnrolledInCourse(@Param("accountId") Long accountId, @Param("courseId") Long courseId); - @Query("select e from Enrollment e where e.payment.user.id = :userId and e.course.id = :courseId") - Enrollment findEnrollmentByUserAndCourse(@Param("userId") Long userId, @Param("courseId") Long courseId); + @Query("select e from Enrollment e where e.payment.account.id = :accountId and e.course.id = :courseId") + Enrollment findEnrollmentByAccountAndCourse(@Param("accountId") Long accountId, @Param("courseId") Long courseId); } Index: backend/src/main/java/com/shifterwebapp/shifter/enrollment/service/EnrollmentService.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/enrollment/service/EnrollmentService.java (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ backend/src/main/java/com/shifterwebapp/shifter/enrollment/service/EnrollmentService.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -11,11 +11,8 @@ import com.shifterwebapp.shifter.enums.PointsConstants; import com.shifterwebapp.shifter.enums.Skills; -import com.shifterwebapp.shifter.exception.ResourceNotFoundException; import com.shifterwebapp.shifter.payment.Payment; import com.shifterwebapp.shifter.payment.PaymentRepository; import com.shifterwebapp.shifter.enums.PaymentStatus; -import com.shifterwebapp.shifter.user.User; -import com.shifterwebapp.shifter.user.UserRepository; -import com.shifterwebapp.shifter.user.service.UserService; +import com.shifterwebapp.shifter.account.service.AccountService; import lombok.RequiredArgsConstructor; import org.springframework.stereotype.Service; @@ -31,5 +28,5 @@ private final CourseRepository courseRepository; private final PaymentRepository paymentRepository; - private final UserService userService; + private final AccountService accountService; private final EnrollmentMapper enrollmentMapper; private final Validate validate; @@ -43,7 +40,7 @@ @Override - public List getEnrollmentsByUser(Long userId) { - validate.validateUserExists(userId); - List enrollment = enrollmentRepository.findEnrollmentsByUser(userId); + public List getEnrollmentsByAccount(Long accountId) { + validate.validateAccountExists(accountId); + List enrollment = enrollmentRepository.findEnrollmentsByAccount(accountId); return enrollmentMapper.toDto(enrollment); } @@ -57,9 +54,9 @@ @Override - public EnrollmentDto getEnrollmentByUserAndCourse(Long userId, Long courseId) { - validate.validateUserExists(userId); + public EnrollmentDto getEnrollmentByAccountAndCourse(Long accountId, Long courseId) { + validate.validateAccountExists(accountId); validate.validateCourseExists(courseId); - Enrollment enrollment = enrollmentRepository.findEnrollmentByUserAndCourse(userId, courseId); + Enrollment enrollment = enrollmentRepository.findEnrollmentByAccountAndCourse(accountId, courseId); return enrollmentMapper.toDto(enrollment); } @@ -67,5 +64,5 @@ @Override - public EnrollmentDto enrollUser(Long courseId, Long paymentId) { + public EnrollmentDto enrollAccount(Long courseId, Long paymentId) { validate.validateCourseExists(courseId); validate.validatePaymentExists(paymentId); @@ -77,9 +74,9 @@ } - Long userId = payment.getUser().getId(); - validate.validateUserExists(userId); - boolean isAlreadyEnrolled = enrollmentRepository.findIsUserEnrolledInCourse(userId, courseId); + Long accountId = payment.getAccount().getId(); + validate.validateAccountExists(accountId); + boolean isAlreadyEnrolled = enrollmentRepository.findIsAccountEnrolledInCourse(accountId, courseId); if (isAlreadyEnrolled) { - throw new RuntimeException("User with ID " + userId + " is already enrolled in course with ID " + courseId + "!"); + throw new RuntimeException("account with ID " + accountId + " is already enrolled in course with ID " + courseId + "!"); } @@ -95,4 +92,5 @@ .build(); + enrollmentRepository.save(enrollment); return enrollmentMapper.toDto(enrollment); @@ -100,13 +98,13 @@ @Override - public Boolean isUserEnrolledInCourse(Long userId, Long courseId) { - validate.validateUserExists(userId); + public Boolean isAccountEnrolledInCourse(Long accountId, Long courseId) { + validate.validateAccountExists(accountId); validate.validateCourseExists(courseId); - return enrollmentRepository.findIsUserEnrolledInCourse(userId, courseId); + return enrollmentRepository.findIsAccountEnrolledInCourse(accountId, courseId); } @Override - public EnrollmentDto updateEnrollmentStatusActive(Long enrollmentId) { + public EnrollmentDto updateEnrollmentStatusToActive(Long enrollmentId) { validate.validateEnrollmentExists(enrollmentId); @@ -118,5 +116,5 @@ } - // CALLING USER SERVICE HERE. IS THERE A BETTER WAY FOR THIS ??? + // CALLING ACCOUNT SERVICE HERE. IS THERE A BETTER WAY FOR THIS ??? @Override public EnrollmentDto updateEnrollmentStatusToCompleted(Long enrollmentId) { @@ -126,9 +124,9 @@ enrollment.setEnrollmentStatus(EnrollmentStatus.COMPLETED); - Long userId = enrollment.getPayment().getUser().getId(); + Long accountId = enrollment.getPayment().getAccount().getId(); List skillsGained = enrollment.getCourse().getSkillsGained(); - userService.addPoints(userId, PointsConstants.BUY_COURSE); - userService.addSkills(userId, skillsGained); - userService.removeSkillGaps(userId, skillsGained); + accountService.addPoints(accountId, PointsConstants.BUY_COURSE); + accountService.addSkills(accountId, skillsGained); + accountService.removeSkillGaps(accountId, skillsGained); enrollmentRepository.save(enrollment); Index: backend/src/main/java/com/shifterwebapp/shifter/enrollment/service/ImplEnrollmentService.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/enrollment/service/ImplEnrollmentService.java (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ backend/src/main/java/com/shifterwebapp/shifter/enrollment/service/ImplEnrollmentService.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -8,13 +8,13 @@ public interface ImplEnrollmentService { EnrollmentDto getEnrollmentById(Long enrollmentId); - List getEnrollmentsByUser(Long userId); + List getEnrollmentsByAccount(Long accountId); List getEnrollmentsByCourse(Long courseId); - EnrollmentDto getEnrollmentByUserAndCourse(Long userId, Long courseId); + EnrollmentDto getEnrollmentByAccountAndCourse(Long accountId, Long courseId); - EnrollmentDto enrollUser(Long courseId, Long paymentId); + EnrollmentDto enrollAccount(Long courseId, Long paymentId); - Boolean isUserEnrolledInCourse(Long userId, Long courseId); + Boolean isAccountEnrolledInCourse(Long accountId, Long courseId); - EnrollmentDto updateEnrollmentStatusActive(Long enrollmentId); + EnrollmentDto updateEnrollmentStatusToActive(Long enrollmentId); EnrollmentDto updateEnrollmentStatusToCompleted(Long enrollmentId); } Index: backend/src/main/java/com/shifterwebapp/shifter/payment/Payment.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/payment/Payment.java (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ backend/src/main/java/com/shifterwebapp/shifter/payment/Payment.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -4,5 +4,5 @@ import com.shifterwebapp.shifter.enums.PaymentMethod; import com.shifterwebapp.shifter.enums.PaymentStatus; -import com.shifterwebapp.shifter.user.User; +import com.shifterwebapp.shifter.account.Account; import jakarta.persistence.*; import lombok.*; @@ -33,6 +33,6 @@ @ManyToOne - @JoinColumn(name = "user_id") - private User user; + @JoinColumn(name = "account_id") + private Account account; @OneToOne(mappedBy = "payment", cascade = CascadeType.ALL, orphanRemoval = true) Index: backend/src/main/java/com/shifterwebapp/shifter/payment/PaymentController.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/payment/PaymentController.java (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ backend/src/main/java/com/shifterwebapp/shifter/payment/PaymentController.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -16,6 +16,6 @@ @GetMapping - public ResponseEntity getPaymentsByUser(@RequestParam("userId") Long userId) { - List paymentDtos = paymentService.getPaymentsByUser(userId); + public ResponseEntity getPaymentsByAccount(@RequestParam("accountId") Long accountId) { + List paymentDtos = paymentService.getPaymentsByAccount(accountId); return ResponseEntity.ok(paymentDtos); } Index: backend/src/main/java/com/shifterwebapp/shifter/payment/PaymentRepository.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/payment/PaymentRepository.java (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ backend/src/main/java/com/shifterwebapp/shifter/payment/PaymentRepository.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -9,5 +9,5 @@ public interface PaymentRepository extends JpaRepository { - List findPaymentByUser_Id(Long userId); + List findPaymentByAccount_Id(Long accountId); @Query("select p from Payment p where p.enrollment.course.id = :courseId") @@ -23,5 +23,5 @@ Double findTotalYearlyRevenueByCourse(@Param("courseId") Long courseId, @Param("year") Integer year); - @Query("select case when p.paymentStatus = 'COMPLETED' then true else false end from Payment p where p.user.id = :userId and p.enrollment.course.id = :courseId") - Boolean findHasUserPaidForCourse(@Param("userId") Long userId, @Param("courseId") Long courseId); + @Query("select case when p.paymentStatus = 'COMPLETED' then true else false end from Payment p where p.account.id = :accountId and p.enrollment.course.id = :courseId") + Boolean findHasAccountPaidForCourse(@Param("accountId") Long accountId, @Param("courseId") Long courseId); } Index: backend/src/main/java/com/shifterwebapp/shifter/payment/service/ImplPaymentService.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/payment/service/ImplPaymentService.java (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ backend/src/main/java/com/shifterwebapp/shifter/payment/service/ImplPaymentService.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -7,5 +7,5 @@ public interface ImplPaymentService { - List getPaymentsByUser(Long userId); + List getPaymentsByAccount(Long accountId); List getPaymentsByCourse(Long courseId); @@ -14,7 +14,7 @@ Double getTotalYearlyRevenueByCourse(Long courseId, Integer year); - Boolean hasUserPaidForCourse(Long userId, Long courseId); + Boolean hasAccountPaidForCourse(Long accountId, Long courseId); - PaymentDto initiatePayment(Long userId, Long courseId, PaymentMethod paymentMethod); + PaymentDto initiatePayment(Long accountId, Long courseId, PaymentMethod paymentMethod); PaymentDto completePayment(Long paymentId); PaymentDto failPayment(Long paymentId); Index: backend/src/main/java/com/shifterwebapp/shifter/payment/service/PaymentService.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/payment/service/PaymentService.java (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ backend/src/main/java/com/shifterwebapp/shifter/payment/service/PaymentService.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -12,6 +12,6 @@ import com.shifterwebapp.shifter.enums.PaymentMethod; import com.shifterwebapp.shifter.enums.PaymentStatus; -import com.shifterwebapp.shifter.user.User; -import com.shifterwebapp.shifter.user.UserRepository; +import com.shifterwebapp.shifter.account.Account; +import com.shifterwebapp.shifter.account.AccountRepository; import lombok.RequiredArgsConstructor; import org.springframework.stereotype.Service; @@ -26,5 +26,5 @@ private final PaymentRepository paymentRepository; private final PaymentMapper paymentMapper; - private final UserRepository userRepository; + private final AccountRepository accountRepository; private final EnrollmentRepository enrollmentRepository; private final CourseRepository courseRepository; @@ -32,7 +32,7 @@ @Override - public List getPaymentsByUser(Long userId) { - validate.validateUserExists(userId); - List payments = paymentRepository.findPaymentByUser_Id(userId); + public List getPaymentsByAccount(Long accountId) { + validate.validateAccountExists(accountId); + List payments = paymentRepository.findPaymentByAccount_Id(accountId); return paymentMapper.toDto(payments); } @@ -64,21 +64,21 @@ @Override - public Boolean hasUserPaidForCourse(Long userId, Long courseId) { + public Boolean hasAccountPaidForCourse(Long accountId, Long courseId) { validate.validateCourseExists(courseId); - validate.validateUserExists(userId); - return paymentRepository.findHasUserPaidForCourse(userId, courseId); + validate.validateAccountExists(accountId); + return paymentRepository.findHasAccountPaidForCourse(accountId, courseId); } @Override - public PaymentDto initiatePayment(Long userId, Long courseId, PaymentMethod paymentMethod) { - validate.validateUserExists(userId); + public PaymentDto initiatePayment(Long accountId, Long courseId, PaymentMethod paymentMethod) { + validate.validateAccountExists(accountId); validate.validateCourseExists(courseId); - User user = userRepository.findById(userId).orElseThrow(); + Account account = accountRepository.findById(accountId).orElseThrow(); Course course = courseRepository.findById(courseId).orElseThrow(); - boolean isAlreadyEnrolled = enrollmentRepository.findIsUserEnrolledInCourse(userId, courseId); + boolean isAlreadyEnrolled = enrollmentRepository.findIsAccountEnrolledInCourse(accountId, courseId); if (isAlreadyEnrolled) { - throw new RuntimeException("User with ID " + userId + " is already enrolled in course with ID " + courseId + " and cannot initiate payment!"); + throw new RuntimeException("Account with ID " + accountId + " is already enrolled in course with ID " + courseId + " and cannot initiate payment!"); } @@ -88,5 +88,5 @@ .paymentMethod(paymentMethod) .date(new Date()) - .user(user) + .account(account) .enrollment(new Enrollment()) .amount(course.getPrice()) Index: backend/src/main/java/com/shifterwebapp/shifter/review/ReviewController.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/review/ReviewController.java (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ backend/src/main/java/com/shifterwebapp/shifter/review/ReviewController.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -2,5 +2,4 @@ import com.shifterwebapp.shifter.review.service.ReviewService; -import com.shifterwebapp.shifter.user.UserDto; import lombok.RequiredArgsConstructor; import org.springframework.http.ResponseEntity; @@ -28,7 +27,7 @@ } - @GetMapping("/{userId}") - public ResponseEntity> getReviewByUser(@PathVariable Long userId) { - List reviewDtos = reviewService.getReviewsByUser(userId); + @GetMapping("/{accountId}") + public ResponseEntity> getReviewByaccount(@PathVariable Long accountId) { + List reviewDtos = reviewService.getReviewsByAccount(accountId); return ResponseEntity.ok(reviewDtos); } Index: backend/src/main/java/com/shifterwebapp/shifter/review/ReviewRepository.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/review/ReviewRepository.java (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ backend/src/main/java/com/shifterwebapp/shifter/review/ReviewRepository.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -15,9 +15,9 @@ List findReviewsByCourse(@Param("courseId") Long courseId); - @Query("select r from Review r where r.enrollment.payment.user.id = :userId") - List findReviewsByUser(@Param("userId") Long userId); + @Query("select r from Review r where r.enrollment.payment.account.id = :accountId") + List findReviewsByAccount(@Param("accountId") Long accountId); @Query("select case when count(r) > 0 then true else false end" + - " from Review r where r.enrollment.payment.user.id = :userId and r.enrollment.course.id = :userId") - Boolean findHasBeenReviewedByUser(@Param("userId") Long userId, @Param("courseId") Long courseId); + " from Review r where r.enrollment.payment.account.id = :accountId and r.enrollment.course.id = :accountId") + Boolean findHasBeenReviewedByAccount(@Param("accountId") Long accountId, @Param("courseId") Long courseId); } Index: backend/src/main/java/com/shifterwebapp/shifter/review/service/ImplReviewService.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/review/service/ImplReviewService.java (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ backend/src/main/java/com/shifterwebapp/shifter/review/service/ImplReviewService.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -8,9 +8,9 @@ ReviewDto getReviewById(Long id); List getReviewsByCourse(Long courseId); - List getReviewsByUser(Long userId); + List getReviewsByAccount(Long accountId); Float getAverageRatingByCourse(Long courseId); ReviewDto writeReview(Long enrollmentId, ReviewDto reviewDto); - Boolean hasBeenReviewedByUser(Long userId, Long courseId); + Boolean hasBeenReviewedByAccount(Long accountId, Long courseId); } Index: backend/src/main/java/com/shifterwebapp/shifter/review/service/ReviewService.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/review/service/ReviewService.java (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ backend/src/main/java/com/shifterwebapp/shifter/review/service/ReviewService.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -39,7 +39,7 @@ @Override - public List getReviewsByUser(Long userId) { - validate.validateUserExists(userId); - List reviews = reviewRepository.findReviewsByUser(userId); + public List getReviewsByAccount(Long accountId) { + validate.validateAccountExists(accountId); + List reviews = reviewRepository.findReviewsByAccount(accountId); return reviewMapper.toDto(reviews); } @@ -61,5 +61,5 @@ } if (enrollment.getEnrollmentStatus() != EnrollmentStatus.COMPLETED) { - throw new RuntimeException("Cannot review a course that has not been completed by user!"); + throw new RuntimeException("Cannot review a course that has not been completed by account!"); } @@ -78,8 +78,8 @@ @Override - public Boolean hasBeenReviewedByUser(Long userId, Long courseId) { - validate.validateUserExists(userId); + public Boolean hasBeenReviewedByAccount(Long accountId, Long courseId) { + validate.validateAccountExists(accountId); validate.validateCourseExists(courseId); - return reviewRepository.findHasBeenReviewedByUser(userId, courseId); + return reviewRepository.findHasBeenReviewedByAccount(accountId, courseId); } } Index: ckend/src/main/java/com/shifterwebapp/shifter/user/PasswordUtil.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/user/PasswordUtil.java (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ (revision ) @@ -1,13 +1,0 @@ -package com.shifterwebapp.shifter.user; - -import org.springframework.security.crypto.password.PasswordEncoder; -import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder; - -public class PasswordUtil { - - private static final PasswordEncoder passwordEncoder = new BCryptPasswordEncoder(); - - public static String hashPassword(String plainPassword) { - return passwordEncoder.encode(plainPassword); - } -} Index: ckend/src/main/java/com/shifterwebapp/shifter/user/User.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/user/User.java (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ (revision ) @@ -1,59 +1,0 @@ -package com.shifterwebapp.shifter.user; - -import com.fasterxml.jackson.annotation.JsonIgnore; -import com.shifterwebapp.shifter.payment.Payment; -import com.shifterwebapp.shifter.enums.CompanyType; -import com.shifterwebapp.shifter.enums.Interests; -import com.shifterwebapp.shifter.enums.Skills; -import jakarta.persistence.*; -import lombok.*; - -import java.util.List; - -@Getter -@Setter -@NoArgsConstructor -@AllArgsConstructor -@Builder -@Entity -@Table(name = "\"user\"") -public class User { - @Id - @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "user_seq") - @SequenceGenerator(name = "user_seq", sequenceName = "user_sequence", allocationSize = 1) - private Long id; - - private String name; - - private String email; - - @JsonIgnore - private String passwordHash; // THIS SHOULD BE CHANGED - - private Boolean isAdmin; - - private CompanyType companyType; - - private String workPosition; - - @ElementCollection(targetClass = Interests.class) - @Enumerated(EnumType.STRING) - private List interests; - - @ElementCollection(targetClass = Skills.class) - @Enumerated(EnumType.STRING) - private List skills; - - @ElementCollection(targetClass = Skills.class) - @Enumerated(EnumType.STRING) - private List skillGap; - - private Integer points; - - @ElementCollection - private List favoriteCourses; - - @OneToMany(mappedBy = "user", cascade = CascadeType.PERSIST, orphanRemoval = true) - private List payments; // WHEN DELETING USER SET PAYMENTS TO NULL, BECAUSE PAYMENTS DONT GET DELETED -} - Index: ckend/src/main/java/com/shifterwebapp/shifter/user/UserController.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/user/UserController.java (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ (revision ) @@ -1,119 +1,0 @@ -package com.shifterwebapp.shifter.user; - -import com.shifterwebapp.shifter.enums.CompanyType; -import com.shifterwebapp.shifter.enums.Interests; -import com.shifterwebapp.shifter.enums.Skills; -import com.shifterwebapp.shifter.payment.Payment; -import com.shifterwebapp.shifter.user.service.UserService; -import lombok.AllArgsConstructor; -import lombok.RequiredArgsConstructor; -import org.springframework.http.ResponseEntity; -import org.springframework.web.bind.annotation.*; - -@RequiredArgsConstructor -@RestController -@RequestMapping("${api.base.path}/user") -public class UserController { - - private final UserService userService; - - @GetMapping("/{userId}") - public ResponseEntity getUser(@PathVariable Long userId) { - UserDto userDto = userService.getUserById(userId); - return ResponseEntity.ok(userDto); - } - - @PostMapping - public ResponseEntity createUser(@RequestBody UserDto userDto) { - try { - UserDto savedUserDto = userService.createUser(userDto); - return ResponseEntity.ok(savedUserDto); - } catch (Exception e) { - return ResponseEntity.badRequest().body(e.getMessage()); - } - } - - @DeleteMapping("/{userId}") - public ResponseEntity deleteUser(@PathVariable Long userId) { - userService.deleteUser(userId); - return ResponseEntity.noContent().build(); - } - - @PutMapping("/{userId}/name") - public ResponseEntity updateName(@PathVariable Long userId, @RequestParam String newName) { - UserDto userDto = userService.updateName(userId, newName); - return ResponseEntity.ok(userDto); - } - - @PutMapping("/{userId}/mail") - public ResponseEntity updateMail(@PathVariable Long userId, @RequestParam String newMail) { - UserDto userDto = userService.updateMail(userId, newMail); - return ResponseEntity.ok(userDto); - } - - @PutMapping("/{userId}/password") - public ResponseEntity updatePassword(@PathVariable Long userId, @RequestParam String newPassword) { - UserDto userDto = userService.updatePassword(userId, newPassword); - return ResponseEntity.ok(userDto); - } - - @PutMapping("/{userId}/work-position") - public ResponseEntity updateWorkPosition(@PathVariable Long userId, @RequestParam String newWorkPosition) { - UserDto userDto = userService.updateWorkPosition(userId, newWorkPosition); - return ResponseEntity.ok(userDto); - } - - @PutMapping("/{userId}/company-type") - public ResponseEntity updateCompanyType(@PathVariable Long userId, @RequestParam CompanyType newCompanyType) { - UserDto userDto = userService.updateCompanyType(userId, newCompanyType); - return ResponseEntity.ok(userDto); - } - - @PutMapping("/{userId}/add/interest") - public ResponseEntity addInterest(@PathVariable Long userId, @RequestParam Interests newInterest) { - UserDto userDto = userService.addInterest(userId, newInterest); - return ResponseEntity.ok(userDto); - } - - @PutMapping("/{userId}/add/skill") - public ResponseEntity addSkill(@PathVariable Long userId, @RequestParam Skills newSkill) { - UserDto userDto = userService.addSkill(userId, newSkill); - return ResponseEntity.ok(userDto); - } - - @PutMapping("/{userId}/add/skill-gap") - public ResponseEntity addSkillGap(@PathVariable Long userId, @RequestParam Skills newSkillGap) { - UserDto userDto = userService.addSkillGap(userId, newSkillGap); - return ResponseEntity.ok(userDto); - } - - @PutMapping("/{userId}/add/favorite-course") - public ResponseEntity addFavoriteCourse(@PathVariable Long userId, @RequestParam Integer newFavoriteCourse) { - UserDto userDto = userService.addFavoriteCourse(userId, newFavoriteCourse); - return ResponseEntity.ok(userDto); - } - - @PutMapping("/{userId}/remove/interest") - public ResponseEntity removeInterest(@PathVariable Long userId, @RequestParam Interests oldInterest) { - UserDto userDto = userService.removeInterest(userId, oldInterest); - return ResponseEntity.ok(userDto); - } - - @PutMapping("/{userId}/remove/skill") - public ResponseEntity removeSkill(@PathVariable Long userId, @RequestParam Skills oldSkill) { - UserDto userDto = userService.removeSkill(userId, oldSkill); - return ResponseEntity.ok(userDto); - } - - @PutMapping("/{userId}/remove/skill-gap") - public ResponseEntity removeSkillGap(@PathVariable Long userId, @RequestParam Skills oldSkillGap) { - UserDto userDto = userService.removeSkillGap(userId, oldSkillGap); - return ResponseEntity.ok(userDto); - } - - @PutMapping("/{userId}/remove/favorite-course") - public ResponseEntity removeFavoriteCourse(@PathVariable Long userId, @RequestParam Integer oldFavoriteCourse) { - UserDto userDto = userService.removeFavoriteCourse(userId, oldFavoriteCourse); - return ResponseEntity.ok(userDto); - } -} Index: ckend/src/main/java/com/shifterwebapp/shifter/user/UserDto.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/user/UserDto.java (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ (revision ) @@ -1,44 +1,0 @@ -package com.shifterwebapp.shifter.user; - -import com.shifterwebapp.shifter.payment.PaymentDto; -import com.shifterwebapp.shifter.enums.CompanyType; -import com.shifterwebapp.shifter.enums.Interests; -import com.shifterwebapp.shifter.enums.Skills; -import lombok.AllArgsConstructor; -import lombok.Data; -import lombok.NoArgsConstructor; - -import java.util.List; - -@Data -@NoArgsConstructor -@AllArgsConstructor -public class UserDto { - - private Long id; - - private String email; - - private String password; - - private String name; - - private CompanyType companyType; - - private String workPosition; - - private List interests; - - private List skills; - - private List skillGap; - - private Integer points; - - private List favoriteCourses; - - private List payments; -} - - - Index: ckend/src/main/java/com/shifterwebapp/shifter/user/UserMapper.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/user/UserMapper.java (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ (revision ) @@ -1,20 +1,0 @@ -package com.shifterwebapp.shifter.user; - -import com.shifterwebapp.shifter.course.Course; -import com.shifterwebapp.shifter.course.CourseDto; -import org.mapstruct.InheritInverseConfiguration; -import org.mapstruct.Mapper; - -import java.util.List; - -@Mapper(componentModel = "spring") -public interface UserMapper { - - UserDto toDto(User user); - List toDto(List users); - - @InheritInverseConfiguration - User toEntity(UserDto userDto); - @InheritInverseConfiguration - List toEntity(List userDtos); -} Index: ckend/src/main/java/com/shifterwebapp/shifter/user/UserRepository.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/user/UserRepository.java (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ (revision ) @@ -1,8 +1,0 @@ -package com.shifterwebapp.shifter.user; - -import org.springframework.data.jpa.repository.JpaRepository; - -public interface UserRepository extends JpaRepository { - - boolean existsUserByEmail(String email); -} Index: ckend/src/main/java/com/shifterwebapp/shifter/user/service/ImplUserService.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/user/service/ImplUserService.java (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ (revision ) @@ -1,42 +1,0 @@ -package com.shifterwebapp.shifter.user.service; - -import com.shifterwebapp.shifter.course.CourseDto; -import com.shifterwebapp.shifter.payment.Payment; -import com.shifterwebapp.shifter.review.ReviewDto; -import com.shifterwebapp.shifter.user.UserDto; -import com.shifterwebapp.shifter.enums.CompanyType; -import com.shifterwebapp.shifter.enums.Interests; -import com.shifterwebapp.shifter.enums.Skills; - -import java.util.List; - -public interface ImplUserService { - List getAllUsers(); - UserDto getUserById(Long id); - - UserDto createUser(UserDto userDto); - void deleteUser(Long id); - - UserDto updateName(Long id, String newName); - UserDto updateMail(Long id, String newMail); - UserDto updatePassword(Long id, String newPassHash); - UserDto updateWorkPosition(Long id, String newWorkPosition); - UserDto updateCompanyType(Long id, CompanyType newCompanyType); - - UserDto addInterest(Long id, Interests newInterest); - UserDto addSkill(Long id, Skills newSkill); - UserDto addSkills(Long id, List newSkills); - UserDto addSkillGap(Long id, Skills newSkillGap); - UserDto addFavoriteCourse(Long id, Integer newFavoriteCourseId); - UserDto addPoints(Long id, Integer newPointsAchieved); - UserDto addPayment(Long id, Payment newPayment); - - UserDto removeInterest(Long id, Interests removeInterest); - UserDto removeSkill(Long id, Skills removeSkill); - UserDto removeSkillGap(Long id, Skills removeSkillGap); - UserDto removeSkillGaps(Long id, List removeSkillGaps); - UserDto removeFavoriteCourse(Long id, Integer removeFavoriteCourseId); - UserDto removePoints(Long id, Integer removePointsAchieved); - UserDto removePayment(Long id, Payment removePayment); - -} Index: ckend/src/main/java/com/shifterwebapp/shifter/user/service/UserService.java =================================================================== --- backend/src/main/java/com/shifterwebapp/shifter/user/service/UserService.java (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ (revision ) @@ -1,266 +1,0 @@ -package com.shifterwebapp.shifter.user.service; - -import com.shifterwebapp.shifter.Validate; -import com.shifterwebapp.shifter.course.CourseDto; -import com.shifterwebapp.shifter.enums.CompanyType; -import com.shifterwebapp.shifter.enums.Interests; -import com.shifterwebapp.shifter.enums.Skills; -import com.shifterwebapp.shifter.payment.Payment; -import com.shifterwebapp.shifter.review.ReviewDto; -import com.shifterwebapp.shifter.user.*; -import lombok.RequiredArgsConstructor; -import org.springframework.stereotype.Service; - -import java.util.List; - -@Service -@RequiredArgsConstructor -public class UserService implements ImplUserService { - - private final UserRepository userRepository; - private final UserMapper userMapper; - private final Validate validate; - - @Override - public List getAllUsers() { - List users = userRepository.findAll(); - return userMapper.toDto(users); - } - - @Override - public UserDto getUserById(Long userId) { - validate.validateUserExists(userId); - User user = userRepository.findById(userId).orElseThrow(); - return userMapper.toDto(user); - } - - @Override - public UserDto createUser(UserDto userDto) { - if (userRepository.existsUserByEmail(userDto.getEmail())) { - throw new RuntimeException("Email already in use"); - } - - User user = User.builder() - .name(userDto.getName()) - .email(userDto.getEmail()) - .passwordHash(PasswordUtil.hashPassword(userDto.getPassword())) - .isAdmin(false) - .companyType(userDto.getCompanyType()) - .workPosition(userDto.getWorkPosition()) - .interests(userDto.getInterests()) - .skills(userDto.getSkills()) - .skillGap(userDto.getSkillGap()) - .points(userDto.getPoints() != null ? userDto.getPoints() : 0) - .favoriteCourses(userDto.getFavoriteCourses()) - .build(); - - return userMapper.toDto(userRepository.save(user)); - } - - @Override - public void deleteUser(Long userId) { - validate.validateUserExists(userId); - userRepository.deleteById(userId); - } - - @Override - public UserDto updateName(Long userId, String newName) { - validate.validateUserExists(userId); - User user = userRepository.findById(userId).orElseThrow(); - user.setName(newName); - userRepository.save(user); - return userMapper.toDto(user); - } - - @Override - public UserDto updateMail(Long userId, String newMail) { - validate.validateUserExists(userId); - User user = userRepository.findById(userId).orElseThrow(); - user.setEmail(newMail); - userRepository.save(user); - return userMapper.toDto(user); - } - - @Override - public UserDto updatePassword(Long userId, String newPass) { - validate.validateUserExists(userId); - User user = userRepository.findById(userId).orElseThrow(); - user.setPasswordHash(PasswordUtil.hashPassword(newPass)); - userRepository.save(user); - return userMapper.toDto(user); - } - - @Override - public UserDto updateWorkPosition(Long userId, String newWorkPosition) { - validate.validateUserExists(userId); - User user = userRepository.findById(userId).orElseThrow(); - user.setWorkPosition(newWorkPosition); - userRepository.save(user); - return userMapper.toDto(user); - } - - @Override - public UserDto updateCompanyType(Long userId, CompanyType newCompanyType) { - validate.validateUserExists(userId); - User user = userRepository.findById(userId).orElseThrow(); - user.setCompanyType(newCompanyType); - userRepository.save(user); - return userMapper.toDto(user); - } - - @Override - public UserDto addInterest(Long userId, Interests newInterest) { - validate.validateUserExists(userId); - User user = userRepository.findById(userId).orElseThrow(); - if (!user.getInterests().contains(newInterest)) { - user.getInterests().add(newInterest); - } - userRepository.save(user); - return userMapper.toDto(user); - } - - @Override - public UserDto addSkill(Long userId, Skills newSkill) { - validate.validateUserExists(userId); - User user = userRepository.findById(userId).orElseThrow(); - if (!user.getSkills().contains(newSkill)) { - user.getSkills().add(newSkill); - } - userRepository.save(user); - return userMapper.toDto(user); - } - - @Override - public UserDto addSkills(Long userId, List newSkills) { - validate.validateUserExists(userId); - User user = userRepository.findById(userId).orElseThrow(); - for (Skills skill : newSkills) { - if (!user.getSkills().contains(skill)) { - user.getSkills().add(skill); - } - } - userRepository.save(user); - return userMapper.toDto(user); - } - - @Override - public UserDto addSkillGap(Long userId, Skills newSkillGap) { - validate.validateUserExists(userId); - User user = userRepository.findById(userId).orElseThrow(); - if (!user.getSkillGap().contains(newSkillGap)) { - user.getSkillGap().add(newSkillGap); - } - userRepository.save(user); - return userMapper.toDto(user); - } - - @Override - public UserDto addFavoriteCourse(Long userId, Integer newFavoriteCourseId) { - validate.validateUserExists(userId); - User user = userRepository.findById(userId).orElseThrow(); - if (!user.getFavoriteCourses().contains(newFavoriteCourseId)) { - user.getFavoriteCourses().add(newFavoriteCourseId); - } - userRepository.save(user); - return userMapper.toDto(user); - } - - @Override - public UserDto addPoints(Long userId, Integer newPointsAchieved) { - validate.validateUserExists(userId); - User user = userRepository.findById(userId).orElseThrow(); - Integer newPoints = user.getPoints() + newPointsAchieved; - user.setPoints(newPoints); - userRepository.save(user); - return userMapper.toDto(user); - } - - @Override - public UserDto addPayment(Long userId, Payment newPayment) { - validate.validateUserExists(userId); - User user = userRepository.findById(userId).orElseThrow(); - if (!user.getPayments().contains(newPayment)) { - user.getPayments().add(newPayment); - } - userRepository.save(user); - return userMapper.toDto(user); - } - - @Override - public UserDto removeInterest(Long userId, Interests removeInterest) { - validate.validateUserExists(userId); - User user = userRepository.findById(userId).orElseThrow(); - if (!user.getInterests().contains(removeInterest)) { - user.getInterests().remove(removeInterest); - } - userRepository.save(user); - return userMapper.toDto(user); - } - - @Override - public UserDto removeSkill(Long userId, Skills removeSkill) { - validate.validateUserExists(userId); - User user = userRepository.findById(userId).orElseThrow(); - if (!user.getSkills().contains(removeSkill)) { - user.getSkills().remove(removeSkill); - } - userRepository.save(user); - return userMapper.toDto(user); - } - - @Override - public UserDto removeSkillGap(Long userId, Skills removeSkillGap) { - validate.validateUserExists(userId); - User user = userRepository.findById(userId).orElseThrow(); - if (!user.getSkillGap().contains(removeSkillGap)) { - user.getSkillGap().remove(removeSkillGap); - } - userRepository.save(user); - return userMapper.toDto(user); - } - - @Override - public UserDto removeSkillGaps(Long userId, List removeSkillGaps) { - validate.validateUserExists(userId); - User user = userRepository.findById(userId).orElseThrow(); - for (Skills skill : removeSkillGaps) { - if (!user.getSkillGap().contains(skill)) { - user.getSkillGap().remove(skill); - } - } - userRepository.save(user); - return userMapper.toDto(user); - } - - @Override - public UserDto removeFavoriteCourse(Long userId, Integer removeFavoriteCourseId) { - validate.validateUserExists(userId); - User user = userRepository.findById(userId).orElseThrow(); - if (!user.getFavoriteCourses().contains(removeFavoriteCourseId)) { - user.getFavoriteCourses().remove(removeFavoriteCourseId); - } - userRepository.save(user); - return userMapper.toDto(user); - } - - @Override - public UserDto removePoints(Long userId, Integer removePointsAchieved) { - validate.validateUserExists(userId); - User user = userRepository.findById(userId).orElseThrow(); - Integer newPoints = user.getPoints() - removePointsAchieved; - user.setPoints(newPoints); - userRepository.save(user); - return userMapper.toDto(user); - } - - @Override - public UserDto removePayment(Long userId, Payment removePayment) { - validate.validateUserExists(userId); - User user = userRepository.findById(userId).orElseThrow(); - if (!user.getPayments().contains(removePayment)) { - user.getPayments().remove(removePayment); - } - userRepository.save(user); - return userMapper.toDto(user); - } -} Index: backend/src/main/resources/application.properties =================================================================== --- backend/src/main/resources/application.properties (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ backend/src/main/resources/application.properties (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -1,10 +1,4 @@ -spring.application.name=Shifter -spring.datasource.url=jdbc:postgresql://${POSTGRES_HOST}:5432/${POSTGRES_DB}?pgbouncer=true -spring.datasource.username=${POSTGRES_USER} -spring.datasource.password=${POSTGRES_PASSWORD} -spring.datasource.driver-class-name=org.postgresql.Driver -spring.jpa.hibernate.ddl-auto=update -spring.jpa.show-sql=true -spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect +spring.datasource.hikari.data-source-properties.useServerPrepStmts=false +spring.datasource.hikari.data-source-properties.prepareThreshold=0 -api.base.path=/api +spring.profiles.active=dev Index: backend/src/test/java/com/shifterwebapp/shifter/ShifterApplicationTests.java =================================================================== --- backend/src/test/java/com/shifterwebapp/shifter/ShifterApplicationTests.java (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ backend/src/test/java/com/shifterwebapp/shifter/ShifterApplicationTests.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -3,5 +3,7 @@ import org.junit.jupiter.api.Test; import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.context.ActiveProfiles; +@ActiveProfiles("test") @SpringBootTest class ShifterApplicationTests { Index: backend/src/test/java/com/shifterwebapp/shifter/unittests/TestEnrollmentService.java =================================================================== --- backend/src/test/java/com/shifterwebapp/shifter/unittests/TestEnrollmentService.java (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ backend/src/test/java/com/shifterwebapp/shifter/unittests/TestEnrollmentService.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -13,5 +13,6 @@ import com.shifterwebapp.shifter.payment.PaymentRepository; import com.shifterwebapp.shifter.enums.PaymentStatus; -import com.shifterwebapp.shifter.user.User; +import com.shifterwebapp.shifter.account.Account; +import com.shifterwebapp.shifter.account.service.AccountService; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; @@ -38,4 +39,6 @@ EnrollmentMapper enrollmentMapper; @Mock + AccountService accountService; + @Mock Validate validate; @InjectMocks @@ -57,35 +60,47 @@ @Test - public void test_getEnrollmentsByUser() { - Long userId = 1L; + public void test_getEnrollmentsByAccount() { + Long accountId = 1L; List enrollments = List.of(enrollment); List dtos = List.of(new EnrollmentDto()); - dtos.get(0).setPercentCompleted(60); + dtos.get(0).setPercentCompleted(1); dtos.get(0).setEnrollmentStatus(EnrollmentStatus.ACTIVE); - Mockito.when(enrollmentRepository.findEnrollmentsByUser(userId)).thenReturn(enrollments); - Mockito.doNothing().when(validate).validateUserExists(userId); + Mockito.when(enrollmentRepository.findEnrollmentsByAccount(accountId)).thenReturn(enrollments); + Mockito.doNothing().when(validate).validateAccountExists(accountId); Mockito.when(enrollmentMapper.toDto(enrollments)).thenReturn(dtos); - List result = enrollmentService.getEnrollmentsByUser(userId); + List result = enrollmentService.getEnrollmentsByAccount(accountId); Assertions.assertEquals(dtos, result); } @Test - public void test_updateEnrollmentStatus() { + public void test_updateEnrollmentStatusToCompleted() { Long enrollmentId = 1L; - EnrollmentStatus newEnrollmentStatus = EnrollmentStatus.COMPLETED; + + Account mockAccount = Mockito.mock(Account.class); + Mockito.when(mockAccount.getId()).thenReturn(2L); + + Payment mockPayment = Mockito.mock(Payment.class); + Mockito.when(mockPayment.getAccount()).thenReturn(mockAccount); + + Course mockCourse = Mockito.mock(Course.class); + Mockito.when(mockCourse.getSkillsGained()).thenReturn(List.of()); + + enrollment.setPayment(mockPayment); + enrollment.setCourse(mockCourse); + EnrollmentDto dto = new EnrollmentDto(); - dto.setPercentCompleted(60); - dto.setEnrollmentStatus(newEnrollmentStatus); + dto.setPercentCompleted(100); + dto.setEnrollmentStatus(EnrollmentStatus.COMPLETED); Mockito.when(enrollmentRepository.findById(enrollmentId)).thenReturn(Optional.of(enrollment)); - Mockito.when(enrollmentRepository.save(enrollment)).thenReturn(null); + Mockito.when(enrollmentRepository.save(enrollment)).thenReturn(enrollment); Mockito.when(enrollmentMapper.toDto(enrollment)).thenReturn(dto); - EnrollmentDto result = enrollmentService.updateEnrollmentStatus(enrollmentId, newEnrollmentStatus); + EnrollmentDto result = enrollmentService.updateEnrollmentStatusToCompleted(enrollmentId); Assertions.assertEquals(dto, result); @@ -93,26 +108,46 @@ @Test - public void test_enrollUser() { + public void test_updateEnrollmentStatusToActive() { + Long enrollmentId = 1L; + + EnrollmentDto dto = new EnrollmentDto(); + dto.setPercentCompleted(1); + dto.setEnrollmentStatus(EnrollmentStatus.ACTIVE); + + Mockito.when(enrollmentRepository.findById(enrollmentId)).thenReturn(Optional.of(enrollment)); + Mockito.when(enrollmentRepository.save(enrollment)).thenReturn(enrollment); + Mockito.when(enrollmentMapper.toDto(enrollment)).thenReturn(dto); + + EnrollmentDto result = enrollmentService.updateEnrollmentStatusToActive(enrollmentId); + + Assertions.assertEquals(dto, result); + } + + @Test + public void test_enrollAccount() { Long courseId = 1L; Long paymentId = 1L; + Long accountId = 1L; EnrollmentDto dto = new EnrollmentDto(); dto.setPercentCompleted(60); dto.setEnrollmentStatus(EnrollmentStatus.ACTIVE); - Payment payment = Payment.builder() - .id(1L) - .paymentStatus(PaymentStatus.COMPLETED) - .user(new User()) - .build(); - Mockito.when(paymentRepository.findById(paymentId)).thenReturn(Optional.of(payment)); + Account mockAccount = Mockito.mock(Account.class); + Mockito.when(mockAccount.getId()).thenReturn(accountId); + + Payment mockPayment = Mockito.mock(Payment.class); + Mockito.when(mockPayment.getAccount()).thenReturn(mockAccount); + Mockito.when(mockPayment.getPaymentStatus()).thenReturn(PaymentStatus.COMPLETED); + + Mockito.when(paymentRepository.findById(paymentId)).thenReturn(Optional.of(mockPayment)); Mockito.doNothing().when(validate).validateCourseExists(courseId); Mockito.doNothing().when(validate).validatePaymentExists(paymentId); - Mockito.doNothing().when(validate).validateUserExists(payment.getUser().getId()); - Mockito.when(enrollmentRepository.findIsUserEnrolledInCourse(payment.getUser().getId(), courseId)).thenReturn(false); + Mockito.doNothing().when(validate).validateAccountExists(accountId); + Mockito.when(enrollmentRepository.findIsAccountEnrolledInCourse(accountId, courseId)).thenReturn(false); Mockito.when(courseRepository.findById(courseId)).thenReturn(Optional.of(new Course())); Mockito.when(enrollmentRepository.save(Mockito.any(Enrollment.class))).thenAnswer(arguments -> arguments.getArgument(0)); Mockito.when(enrollmentMapper.toDto(Mockito.any(Enrollment.class))).thenReturn(dto); - EnrollmentDto result = enrollmentService.enrollUser(courseId, paymentId); + EnrollmentDto result = enrollmentService.enrollAccount(courseId, paymentId); Assertions.assertEquals(dto, result); } Index: backend/src/test/java/com/shifterwebapp/shifter/unittests/TestReviewService.java =================================================================== --- backend/src/test/java/com/shifterwebapp/shifter/unittests/TestReviewService.java (revision e13f128f19b817d19e3e9ba68a26b94d45cef00b) +++ backend/src/test/java/com/shifterwebapp/shifter/unittests/TestReviewService.java (revision 3487c01a2bdc2a11349375008d19da3c5b0c6d78) @@ -77,13 +77,13 @@ @Test - public void test_hasBeenReviewedByUser() { + public void test_hasBeenReviewedByAccount() { Long courseId = 1L; - Long userId = 1L; + Long accountId = 1L; - Mockito.when(reviewRepository.findHasBeenReviewedByUser(userId, courseId)).thenReturn(true); - Mockito.doNothing().when(validate).validateUserExists(userId); + Mockito.when(reviewRepository.findHasBeenReviewedByAccount(accountId, courseId)).thenReturn(true); + Mockito.doNothing().when(validate).validateAccountExists(accountId); Mockito.doNothing().when(validate).validateCourseExists(courseId); - Boolean result = reviewService.hasBeenReviewedByUser(userId, courseId); + Boolean result = reviewService.hasBeenReviewedByAccount(accountId, courseId); Assertions.assertEquals(true, result); }