feat: add services for all models: achievement, benefit, user, exam. fix: repositories and models

app/src/main/java/putBit/app/models/Order.java

@@ -14,8 +14,12 @@ import lombok.NoArgsConstructor;
 public class Order {
 
     @Id
+    @GeneratedValue
+    @Column(name = "id")
+    private int id;
+
     @OneToOne
-    @JoinColumn(name = "user_id")
+    @JoinColumn(name = "user_id", unique = true)
     private User user;
 
     @ManyToOne
@@ -24,4 +28,7 @@ public class Order {
 
     @Column(name = "confirm", columnDefinition = "boolean")
     Boolean confirm = false;
+
+    @Column(name = "benefit", columnDefinition = "boolean")
+    Boolean benefit = false;
 }

app/src/main/java/putBit/app/models/User.java

@@ -60,4 +60,17 @@ public class User {
 
     @OneToOne(fetch = FetchType.EAGER, mappedBy = "user" )
     Order order;
+
+    public void addAchievement(Achievement achievement){
+        achievements.add(achievement);
+    }
+    public void clearAchievements(){
+        achievements.clear();
+    }
+    public void addBenefit(Benefit benefit){
+        benefits.add(benefit);
+    }
+    public void clearBenefit(){
+        benefits.clear();
+    }
 }

app/src/main/java/putBit/app/repositories/AchievementRepository.java

@@ -13,7 +13,7 @@ import java.util.UUID;
 
 public interface AchievementRepository extends JpaRepository<Achievement, Integer> {
 
-    Optional<List<Achievement>> findAchievementsByUserId(int userId);
+    Optional<List<Achievement>> findAchievementsByUsersId(int userId);
 
-    Optional<List<Benefit>> findAchievementsByUserIdNot(int userId);
+    Optional<List<Achievement>> findAchievementsByUsersIdNot(int userId);
 }

app/src/main/java/putBit/app/repositories/BenefitRepository.java

@@ -7,8 +7,8 @@ import java.util.List;
 import java.util.Optional;
 
 public interface BenefitRepository extends JpaRepository<Benefit, Integer> {
-    Optional<List<Benefit>> findBenefitsByUserId(int userId);
+    Optional<List<Benefit>> findBenefitsByUsersId(int userId);
 
-    Optional<List<Benefit>> findBenefitsByUserIdNot(int userId);
+    Optional<List<Benefit>> findBenefitsByUsersIdNot(int userId);
 
 }

app/src/main/java/putBit/app/repositories/ExamRepository.java

@@ -1,11 +1,18 @@
 package putBit.app.repositories;
 
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
 import putBit.app.models.Exam;
 import putBit.app.models.User;
 
+import java.util.List;
 import java.util.Optional;
 
 public interface ExamRepository extends JpaRepository<Exam, Integer> {
 
+    @Query(value = "select e.* from exams e " +
+            "where e.id not in (select er.exam_id from exam_results er " +
+            "where er.user_id = :id )", nativeQuery = true)
+    Optional<List<Exam>> findByUserIdNot(@Param("id") int id);
 }

app/src/main/java/putBit/app/repositories/OrderRepository.java

@@ -5,14 +5,17 @@ import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
 import putBit.app.models.Order;
 import putBit.app.models.Training;
+import putBit.app.models.User;
 
 import java.util.List;
 import java.util.Optional;
 
-public interface OrderRepository extends JpaRepository<Order, Integer> {
+public interface OrderRepository extends JpaRepository<Order, User> {
     @Query(value = "select o.* from orders where " +
             "o.user_id = (select u.id from users u where " +
             "u.name LIKE %:name% or u.snils like %:snils%) " , nativeQuery = true)
     Optional<List<Order>> findByUserInfo(@Param("snils")String snils, @Param("name")String name);
 
+
+    Optional<List<Order>> findByBenefit(Boolean benefit);
 }

app/src/main/java/putBit/app/repositories/TrainingRepository.java

@@ -7,7 +7,7 @@ import putBit.app.models.User;
 import java.util.List;
 import java.util.Optional;
 
-public interface TrainingRepository extends JpaRepository<TrainingRepository, Integer> {
+public interface TrainingRepository extends JpaRepository<Training, Integer> {
 
     Optional<List<Training>> findByNumContainingOrTitleContaining(String num, String title);
 }

app/src/main/java/putBit/app/services/AchievementService.java

@@ -0,0 +1,61 @@
+package putBit.app.services;
+
+import lombok.RequiredArgsConstructor;
+import org.hibernate.sql.exec.ExecutionException;
+import org.springframework.stereotype.Service;
+import putBit.app.models.Achievement;
+import putBit.app.models.User;
+import putBit.app.repositories.AchievementRepository;
+
+import java.util.List;
+
+@Service
+@RequiredArgsConstructor
+public class AchievementService {
+
+    private final AchievementRepository achievementRepository;
+    private final UserService userService;
+
+
+    public Achievement create(Achievement achievement){
+        Achievement newAchievement = Achievement.builder()
+                .title(achievement.getTitle())
+                .points(achievement.getPoints())
+                .build();
+        return achievementRepository.save(newAchievement);
+    }
+
+    public Achievement findById(int id){
+        return achievementRepository.findById(id)
+                .orElseThrow(() -> new ExecutionException("Достижение не найдено"));
+    }
+
+    public Achievement update(Achievement achievement)
+    {
+        Achievement currentAchievement = findById(achievement.getId());
+
+        currentAchievement.setTitle(achievement.getTitle());
+        currentAchievement.setPoints(achievement.getPoints());
+        return achievementRepository.save(currentAchievement);
+    }
+
+    public Achievement delete(Achievement achievement){
+        Achievement currentAchievement = findById(achievement.getId());
+        achievementRepository.delete(currentAchievement);
+        return currentAchievement;
+    }
+
+    public List<Achievement> findAll(){
+        return achievementRepository.findAll();
+    }
+
+    public List<Achievement> findByUser(User user){
+        return achievementRepository.findAchievementsByUsersId(user.getId())
+                .orElseThrow(() -> new ExecutionException("Достижений не найдено"));
+    }
+
+    public List<Achievement> findByUserNot(User user){
+        return achievementRepository.findAchievementsByUsersIdNot(user.getId())
+                .orElseThrow(() -> new ExecutionException("Достижений не найдено"));
+    }
+}

app/src/main/java/putBit/app/services/BenefitService.java

@@ -0,0 +1,62 @@
+package putBit.app.services;
+
+import lombok.RequiredArgsConstructor;
+import org.hibernate.sql.exec.ExecutionException;
+import org.springframework.stereotype.Service;
+import putBit.app.models.Achievement;
+import putBit.app.models.Benefit;
+import putBit.app.models.User;
+import putBit.app.repositories.BenefitRepository;
+
+import java.util.List;
+
+@Service
+@RequiredArgsConstructor
+public class BenefitService {
+
+    private final BenefitRepository benefitRepository;
+
+    private final UserService userService;
+
+
+    public Benefit create(Benefit benefit){
+        Benefit newBenefit = Benefit.builder()
+                .title(benefit.getTitle())
+                .build();
+        return benefitRepository.save(newBenefit);
+    }
+
+    public Benefit findById(int id){
+        return benefitRepository.findById(id)
+                .orElseThrow(() -> new ExecutionException("Льгота не найдена"));
+    }
+
+    public Benefit update(Benefit benefit)
+    {
+        Benefit currentBenefit = findById(benefit.getId());
+
+        currentBenefit.setTitle(benefit.getTitle());
+        return benefitRepository.save(currentBenefit);
+    }
+
+    public Benefit delete(Benefit benefit){
+        Benefit currentBenefit = findById(benefit.getId());
+        benefitRepository.delete(currentBenefit);
+        return currentBenefit;
+    }
+
+    public List<Benefit> findAll(){
+        return benefitRepository.findAll();
+    }
+
+    public List<Benefit> findByUser(User user){
+        return benefitRepository.findBenefitsByUsersId(user.getId())
+                .orElseThrow(() -> new ExecutionException("Льгот не найдено"));
+    }
+
+    public List<Benefit> findByUserNot(User user){
+        return benefitRepository.findBenefitsByUsersIdNot(user.getId())
+                .orElseThrow(() -> new ExecutionException("Льгот не найдено"));
+    }
+
+}

app/src/main/java/putBit/app/services/ExamService.java

@@ -0,0 +1,52 @@
+package putBit.app.services;
+
+import lombok.RequiredArgsConstructor;
+import org.hibernate.sql.exec.ExecutionException;
+import org.springframework.stereotype.Service;
+import putBit.app.models.Exam;
+import putBit.app.models.User;
+import putBit.app.models.enums.Role;
+import putBit.app.repositories.ExamRepository;
+
+import java.util.List;
+
+@Service
+@RequiredArgsConstructor
+public class ExamService {
+    private final ExamRepository examRepository;
+
+    public Exam create(Exam exam){
+        Exam newExam = Exam.builder()
+                .title(exam.getTitle())
+                .build();
+        return examRepository.save(newExam);
+    }
+
+    public Exam findById(int id){
+        return examRepository.findById(id)
+                .orElseThrow(() -> new ExecutionException("Экзамен не найден"));
+    }
+
+    public Exam update(Exam exam)
+    {
+        Exam currentExam = findById(exam.getId());
+
+       currentExam.setTitle(exam.getTitle());
+        return examRepository.save(currentExam);
+    }
+
+    public Exam delete(Exam exam){
+        Exam currentExam = findById(exam.getId());
+        examRepository.delete(currentExam);
+        return currentExam;
+    }
+
+    public List<Exam> findAll(){
+        return examRepository.findAll();
+    }
+    public List<Exam> findNotUser(User user){
+        return examRepository.findByUserIdNot(user.getId())
+                .orElseThrow(() -> new ExecutionException("Экзамен не найден"));
+    }
+
+}

app/src/main/java/putBit/app/services/UserService.java

@@ -0,0 +1,81 @@
+package putBit.app.services;
+
+import lombok.RequiredArgsConstructor;
+import org.hibernate.sql.exec.ExecutionException;
+import org.springframework.stereotype.Service;
+import putBit.app.models.Achievement;
+import putBit.app.models.Benefit;
+import putBit.app.models.User;
+import putBit.app.models.enums.Role;
+import putBit.app.repositories.UserRepository;
+
+@Service
+@RequiredArgsConstructor
+public class UserService {
+    private final UserRepository userRepository;
+
+    private final BenefitService benefitService;
+    private final AchievementService achievementService;
+
+    public User create(User user){
+        User newUser = User.builder()
+                .email(user.getEmail())
+                .password(user.getPassword())
+                .phone(user.getPhone())
+                .role(Role.USER)
+                .name(user.getName())
+                .snils(user.getSnils())
+                .build();
+        return userRepository.save(newUser);
+    }
+
+    public User findById(int id){
+        return userRepository.findById(id)
+                .orElseThrow(() -> new ExecutionException("Пользователь не найден"));
+    }
+
+    public User auth(User user)
+    {
+        return userRepository.findByEmailAndPassword(user.getEmail(), user.getPassword())
+                .orElseThrow(() -> new ExecutionException("Пользователь не найден"));
+    }
+
+    public User update(User user)
+    {
+        User currentUser = findById(user.getId());
+
+        if(!user.getName().isEmpty() && !currentUser.getName().equals(user.getName()))
+            currentUser.setName(user.getName());
+        if(!user.getEmail().isEmpty() && !currentUser.getEmail().equals(user.getEmail()))
+            currentUser.setName(user.getEmail());
+        if(!user.getPassword().isEmpty() && !currentUser.getPassword().equals(user.getPassword()))
+            currentUser.setPassword(user.getPassword());
+        if(!user.getPhone().isEmpty() && !currentUser.getPhone().equals(user.getPhone()))
+            currentUser.setPhone(user.getPhone());
+        if(!user.getSnils().isEmpty() && !currentUser.getSnils().equals(user.getSnils()))
+            currentUser.setSnils(user.getSnils());
+        if(!user.getAchievements().isEmpty())
+        {
+            for(Achievement ach:
+                    user.getAchievements()
+            ){
+                Achievement newAch = achievementService.findById(ach.getId());
+                currentUser.addAchievement(newAch);
+            }
+        }
+        else
+            currentUser.clearAchievements();
+        if(!user.getBenefits().isEmpty())
+        {
+            for(Benefit benefit:
+                    user.getBenefits()
+            ){
+                Benefit newBenefit = benefitService.findById(benefit.getId());
+                currentUser.addBenefit(newBenefit);
+            }
+        }
+        else
+            currentUser.clearBenefit();
+        return userRepository.save(currentUser);
+    }
+}