feat: add classes of primary key for exam_result, training_result, order. add new exceptions. fix: all classes

.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

.idea/PutBit.iml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/misc.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_19" default="true" project-jdk-name="19" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/PutBit.iml" filepath="$PROJECT_DIR$/.idea/PutBit.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

app/.gitignore

@@ -1,4 +1,5 @@
 HELP.md
+data.mv.db
 target/
 !.mvn/wrapper/maven-wrapper.jar
 !**/src/main/**/target/

app/.mvn/wrapper/maven-wrapper.properties

@@ -0,0 +1,19 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+wrapperVersion=3.3.2
+distributionType=only-script
+distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.9/apache-maven-3.9.9-bin.zip

app/pom.xml

@@ -30,6 +30,13 @@
 		<java.version>17</java.version>
 	</properties>
 	<dependencies>
+
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-actuator</artifactId>
+			<version>3.2.4</version>
+		</dependency>
+
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-data-jpa</artifactId>
@@ -58,18 +65,6 @@
 
 	<build>
 		<plugins>
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-compiler-plugin</artifactId>
-				<configuration>
-					<annotationProcessorPaths>
-						<path>
-							<groupId>org.projectlombok</groupId>
-							<artifactId>lombok</artifactId>
-						</path>
-					</annotationProcessorPaths>
-				</configuration>
-			</plugin>
 			<plugin>
 				<groupId>org.springframework.boot</groupId>
 				<artifactId>spring-boot-maven-plugin</artifactId>
@@ -84,5 +79,4 @@
 			</plugin>
 		</plugins>
 	</build>
-
 </project>

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

@@ -0,0 +1,31 @@
+package putBit.app.models;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Entity(name = "achievements")
+public class Achievement {
+    @Id
+    @GeneratedValue
+    @Column(name = "id")
+    private int id;
+
+
+    @Column(name = "title", unique = true, nullable = false, length = 20)
+    private String title ;
+
+    @Column(name = "points", nullable = false, length = 3)
+    private int points ;
+
+    @ManyToMany(mappedBy = "achievements")
+    List<User> users;
+}

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

@@ -0,0 +1,28 @@
+package putBit.app.models;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Entity(name = "benefits")
+public class Benefit {
+    @Id
+    @GeneratedValue
+    @Column(name = "id")
+    private int id;
+
+
+    @Column(name = "title", unique = true,nullable = false, length = 20)
+    private String title ;
+
+    @ManyToMany(mappedBy = "benefits")
+    List<User> users;
+}

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

@@ -0,0 +1,32 @@
+package putBit.app.models;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+import java.util.UUID;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Entity(name = "exams")
+public class Exam {
+    @Id
+    @GeneratedValue
+    @Column(name = "id")
+    private int id;
+
+
+    @Column(name = "title", unique = true, nullable = false, length = 20)
+    private String title ;
+
+    @OneToMany(fetch = FetchType.EAGER,cascade = CascadeType.REMOVE, mappedBy = "exam")
+    List<ExamResult> users;
+
+    @OneToMany(fetch = FetchType.EAGER,cascade = CascadeType.REMOVE, mappedBy = "exam")
+    List<TrainingExam> trainings;
+}

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

@@ -0,0 +1,31 @@
+package putBit.app.models;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import putBit.app.models.PrimaryKey.ExamResultPK;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@IdClass(ExamResultPK.class)
+@Entity(name = "exam_results")
+public class ExamResult {
+
+    @Id
+    @ManyToOne
+    @JoinColumn(name = "user_id", nullable = false)
+    private User user ;
+
+    @Id
+    @ManyToOne
+    @JoinColumn(name = "exam_id", nullable = false)
+    private Exam exam ;
+
+    @Column(name = "points", nullable = false,unique = false, length = 3)
+    private int points ;
+
+}

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

@@ -0,0 +1,35 @@
+package putBit.app.models;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.hibernate.annotations.Cascade;
+import putBit.app.models.PrimaryKey.OrderPK;
+import putBit.app.models.PrimaryKey.TrainingExamPK;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@IdClass(OrderPK.class)
+@Entity(name = "orders")
+public class Order {
+
+    @Id
+    @OneToOne
+    @JoinColumn(name = "user_id", unique = true,nullable = false)
+    private User user;
+
+    @Id
+    @ManyToOne
+    @JoinColumn(name = "training_id",nullable = false)
+    private Training training;
+
+    @Column(name = "confirm", columnDefinition = "boolean",nullable = false)
+    private Boolean confirm ;
+
+    @Column(name = "benefit", columnDefinition = "boolean",nullable = false)
+    private Boolean benefit ;
+}

app/src/main/java/putBit/app/models/PrimaryKey/ExamResultPK.java

@@ -0,0 +1,24 @@
+package putBit.app.models.PrimaryKey;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import putBit.app.models.Exam;
+import putBit.app.models.User;
+
+import java.io.Serializable;
+
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class ExamResultPK implements Serializable {
+
+    private int user;
+
+    private int exam;
+
+
+}

app/src/main/java/putBit/app/models/PrimaryKey/OrderPK.java

@@ -0,0 +1,21 @@
+package putBit.app.models.PrimaryKey;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.io.Serializable;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class OrderPK implements Serializable {
+
+    private int user;
+
+    private int training;
+
+
+}

app/src/main/java/putBit/app/models/PrimaryKey/TrainingExamPK.java

@@ -0,0 +1,24 @@
+package putBit.app.models.PrimaryKey;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import putBit.app.models.Exam;
+import putBit.app.models.Training;
+import putBit.app.models.User;
+
+import java.io.Serializable;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class TrainingExamPK implements Serializable {
+
+    private int training;
+
+    private int exam;
+
+
+}

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

@@ -0,0 +1,47 @@
+package putBit.app.models;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Entity(name = "trainings")
+public class Training {
+
+    @Id
+    @GeneratedValue
+    @Column(name = "id")
+    private int id;
+
+    @Column(name = "num", unique = true, nullable = false, length = 11)
+    private String num ;
+
+    @Column(name = "title", unique = true, nullable = false, length = 50)
+    private String title ;
+
+    @Column(name = "desc", nullable = false, length = 300)
+    private String desc ;
+
+    @Column(name = "prof", nullable = false, length = 300)
+    private String prof ;
+
+    @Column(name = "basic_places", nullable = false, length = 3)
+    private int basic_places ;
+
+    @Column(name = "benefit_places", nullable = false, length = 3)
+    private int benefit_places ;
+
+    @OneToMany(fetch = FetchType.EAGER,cascade = CascadeType.REMOVE, mappedBy = "training")
+    List<TrainingExam> exams;
+
+    @OneToMany(fetch = FetchType.EAGER, cascade = CascadeType.REMOVE, mappedBy = "training")
+    List<Order> orders;
+
+}

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

@@ -0,0 +1,32 @@
+package putBit.app.models;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import putBit.app.models.PrimaryKey.TrainingExamPK;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@IdClass(TrainingExamPK.class)
+@Entity(name = "training_exams")
+public class TrainingExam {
+
+
+    @Id
+    @ManyToOne
+    @JoinColumn(name = "training_id", nullable = false)
+    private Training training ;
+
+    @Id
+    @ManyToOne
+    @JoinColumn(name = "exam_id", nullable = false)
+    private Exam exam ;
+
+    @Column(name = "points", nullable = false, length = 3)
+    private int points ;
+
+}

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

@@ -0,0 +1,100 @@
+package putBit.app.models;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import putBit.app.models.enums.Role;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Entity(name = "users")
+public class User {
+    @Id
+    @GeneratedValue
+    @Column(name = "id")
+    private int id;
+
+    @Enumerated(EnumType.STRING)
+    @Column(name = "role", nullable = false)
+    private Role role;
+
+    @Column(name = "email", nullable = false)
+    private String email;
+
+    @Column(name = "password", nullable = false, length = 20)
+    private String password;
+
+    @Column(name = "phone", length = 12)
+    private String phone;
+
+
+    @Column(name = "name", nullable = false, length = 80)
+    private String name;
+
+    @Column(name = "snils", unique = true, length = 11)
+    private String snils;
+
+    @ManyToMany(fetch = FetchType.EAGER)
+    @JoinTable(
+            name = "user_achievements",
+            joinColumns = @JoinColumn(name = "user_id"),
+            inverseJoinColumns = @JoinColumn(name = "achievements_id"))
+    Set<Achievement> achievements;
+
+    @ManyToMany(fetch = FetchType.EAGER)
+    @JoinTable(
+            name = "user_benefits",
+            joinColumns = @JoinColumn(name = "user_id"),
+            inverseJoinColumns = @JoinColumn(name = "benefits_id"))
+    Set<Benefit> benefits;
+
+    @OneToMany(fetch = FetchType.EAGER,cascade = CascadeType.REMOVE, mappedBy = "user")
+    List<ExamResult> exams;
+
+    @OneToOne(fetch = FetchType.EAGER,cascade = CascadeType.REMOVE, mappedBy = "user" )
+    Order order;
+
+    public void addAchievement(Achievement achievement){
+        achievements.add(achievement);
+    }
+    public boolean deleteAchievement(Achievement achievement){
+        for(Achievement ach:
+        achievements)
+        {
+         if (ach.getId() == achievement.getId()) {
+             achievements.remove(ach);
+             return true;
+         }
+
+        }
+        return false;
+
+    }
+
+
+    public void addBenefit(Benefit benefit){
+        benefits.add(benefit);
+    }
+    public boolean deleteBenefit(Benefit benefit){
+        for(Benefit ben:
+                benefits)
+        {
+            if (ben.getId() == benefit.getId()) {
+                benefits.remove(ben);
+                return true;
+            }
+
+        }
+        return false;
+    }
+
+}

app/src/main/java/putBit/app/models/enums/Role.java

@@ -0,0 +1,6 @@
+package putBit.app.models.enums;
+
+public enum Role {
+    USER,
+    ADMIN,
+}

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

@@ -0,0 +1,28 @@
+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.Achievement;
+import putBit.app.models.Benefit;
+import putBit.app.models.ExamResult;
+import putBit.app.models.User;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+public interface AchievementRepository extends JpaRepository<Achievement, Integer> {
+
+    @Query(value = "select a.* from achievements a " +
+            "where a.id in (select ua.achievements_id from USER_ACHIEVEMENTS ua " +
+            "where ua.user_id = :id)", nativeQuery = true)
+    List<Achievement> findAchievementsByUsersId(@Param("id") int userId);
+
+
+
+    @Query(value = "select a.* from achievements a " +
+            "where a.id not in (select ua.achievements_id from USER_ACHIEVEMENTS ua " +
+            "where ua.user_id = :id)", nativeQuery = true)
+    List<Achievement> findAchievementsByUsersIdNot(@Param("id") int userId);
+}

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

@@ -0,0 +1,25 @@
+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.Benefit;
+import putBit.app.models.User;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface BenefitRepository extends JpaRepository<Benefit, Integer> {
+
+    @Query(value = "select b.* from benefits b " +
+            "where b.id in (select ub.benefits_id from USER_BENEFITS ub " +
+            "where ub.user_id = :id)", nativeQuery = true)
+    List<Benefit> findBenefitsByUsersId(@Param("id") int userId);
+
+
+    @Query(value = "select b.* from benefits b " +
+            "where b.id not in (select ub.benefits_id from USER_BENEFITS ub " +
+            "where ub.user_id = :id)", nativeQuery = true)
+    List<Benefit> findBenefitsByUsersIdNot(@Param("id") int userId);
+
+}

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

@@ -0,0 +1,23 @@
+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)
+    List<Exam> findByUserIdNot(@Param("id") int id);
+
+    @Query(value = "select e.* from exams e " +
+            "where e.id not in (select te.exam_id from training_exams te " +
+            "where te.training_id = :id )", nativeQuery = true)
+    List<Exam> findByTrainingIdNot(@Param("id") int id);
+}

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

@@ -0,0 +1,17 @@
+package putBit.app.repositories;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import putBit.app.models.Exam;
+import putBit.app.models.ExamResult;
+import putBit.app.models.PrimaryKey.ExamResultPK;
+import putBit.app.models.User;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface ExamResultRepository extends JpaRepository<ExamResult, ExamResultPK> {
+
+    Optional<ExamResult> findByUserAndExam(User user, Exam exam);
+
+    List<ExamResult> findAllByUser(User user);
+}

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

@@ -0,0 +1,22 @@
+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.Order;
+import putBit.app.models.PrimaryKey.OrderPK;
+import putBit.app.models.Training;
+import putBit.app.models.User;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface OrderRepository extends JpaRepository<Order, OrderPK> {
+    @Query(value = "select o.* from orders where " +
+            "o.user_id = (select u.id from users u where " +
+            "u.name LIKE %:value% or u.snils like %:value%) " , nativeQuery = true)
+    List<Order> findByUserInfo(@Param("value")String value);
+
+
+    List<Order> findAllByBenefit(Boolean benefit);
+}

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

@@ -0,0 +1,16 @@
+package putBit.app.repositories;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import putBit.app.models.*;
+import putBit.app.models.PrimaryKey.TrainingExamPK;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface TrainingExamRepository extends JpaRepository<TrainingExam, TrainingExamPK> {
+
+    List<TrainingExam> findAllByTraining(Training training);
+
+
+    Optional<TrainingExam> findByTrainingAndExam(Training training, Exam exam);
+}

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

@@ -0,0 +1,13 @@
+package putBit.app.repositories;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import putBit.app.models.Training;
+import putBit.app.models.User;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface TrainingRepository extends JpaRepository<Training, Integer> {
+
+    List<Training> findAllByTitleContaining(String title);
+}

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

@@ -0,0 +1,25 @@
+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.User;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+public interface UserRepository extends JpaRepository<User, Integer> {
+
+    @Query(value = "select u.* from users u " +
+            "where u.id in (select ua.user_id from USER_ACHIEVEMENTS ua " +
+            "where ua.achievements_id = :id)", nativeQuery = true)
+    List<User> findUsersByAchievementsId(@Param("id")int AchievementId);
+
+    @Query(value = "select u.* from users u " +
+            "where u.id in (select ub.user_id from USER_BENEFITS ub " +
+            "where ub.benefits_id = :id)", nativeQuery = true)
+    List<User> findUsersByBenefitsId(@Param("id")int AchievementId);
+
+    Optional<User> findByEmailAndPassword(String email, String password);
+}

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

@@ -0,0 +1,79 @@
+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 putBit.app.repositories.UserRepository;
+import putBit.app.services.exceptions.EntityNotFoundException;
+import putBit.app.services.exceptions.ValidationException;
+
+import java.util.List;
+
+@Service
+@RequiredArgsConstructor
+public class AchievementService {
+
+    private final AchievementRepository achievementRepository;
+
+    private final UserRepository userRepository;
+
+    public Achievement create(Achievement achievement){
+
+        if(achievement.getTitle().isEmpty() || (achievement.getTitle().length() < 3 || achievement.getTitle().length() > 20  ) )
+            throw new ValidationException("Неверные данные");
+        if(achievement.getPoints() > 10 || achievement.getPoints() < 0 )
+            throw new ValidationException("Неверные данные");
+
+        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 EntityNotFoundException("Достижение не найдено"));
+    }
+
+    public Achievement update(Achievement achievement)
+    {
+        if(achievement.getTitle().isEmpty() || (achievement.getTitle().length() < 3 || achievement.getTitle().length() > 20  ) )
+            throw new ValidationException("Неверные данные");
+        if(achievement.getPoints() > 10 || achievement.getPoints() < 0 )
+            throw new ValidationException("Неверные данные");
+
+        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());
+        List<User> users = userRepository.findUsersByAchievementsId(achievement.getId());
+        for(User user:
+                users){
+            user.deleteAchievement(currentAchievement);
+            userRepository.save(user);
+        }
+        achievementRepository.delete(currentAchievement);
+        return currentAchievement;
+    }
+
+    public List<Achievement> findAll(){
+        return achievementRepository.findAll();
+    }
+
+    public List<Achievement> findByUser(User user){
+        return achievementRepository.findAchievementsByUsersId(user.getId());
+    }
+
+    public List<Achievement> findByUserNot(User user){
+        return achievementRepository.findAchievementsByUsersIdNot(user.getId());
+    }
+}

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

@@ -0,0 +1,74 @@
+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 putBit.app.repositories.UserRepository;
+import putBit.app.services.exceptions.EntityNotFoundException;
+import putBit.app.services.exceptions.ValidationException;
+
+import java.util.List;
+
+@Service
+@RequiredArgsConstructor
+public class BenefitService {
+
+    private final BenefitRepository benefitRepository;
+
+    private final UserRepository userRepository;
+
+    public Benefit create(Benefit benefit){
+
+        if(benefit.getTitle().isEmpty() || (benefit.getTitle().length() < 3 || benefit.getTitle().length() > 20  ) )
+            throw new ValidationException("Неверные данные");
+
+        Benefit newBenefit = Benefit.builder()
+                .title(benefit.getTitle())
+                .build();
+        return benefitRepository.save(newBenefit);
+    }
+
+    public Benefit findById(int id){
+        return benefitRepository.findById(id)
+                .orElseThrow(() -> new EntityNotFoundException("Льгота не найдена"));
+    }
+
+    public Benefit update(Benefit benefit)
+    {
+        if(benefit.getTitle().isEmpty() || (benefit.getTitle().length() < 3 || benefit.getTitle().length() > 20  ) )
+            throw new ValidationException("Неверные данные");
+
+        Benefit currentBenefit = findById(benefit.getId());
+        currentBenefit.setTitle(benefit.getTitle());
+        return benefitRepository.save(currentBenefit);
+    }
+
+    public Benefit delete(Benefit benefit){
+        Benefit currentBenefit = findById(benefit.getId());
+        List<User> users = userRepository.findUsersByBenefitsId(benefit.getId());
+        for(User user:
+                users){
+            user.deleteBenefit(currentBenefit);
+            userRepository.save(user);
+        }
+        benefitRepository.delete(currentBenefit);
+        return currentBenefit;
+    }
+
+    public List<Benefit> findAll(){
+        return benefitRepository.findAll();
+    }
+
+    public List<Benefit> findByUser(User user){
+        return benefitRepository.findBenefitsByUsersId(user.getId());
+    }
+
+    public List<Benefit> findByUserNot(User user){
+        return benefitRepository.findBenefitsByUsersIdNot(user.getId());
+    }
+
+}

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

@@ -0,0 +1,67 @@
+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.ExamResult;
+import putBit.app.models.PrimaryKey.ExamResultPK;
+import putBit.app.models.User;
+import putBit.app.repositories.ExamResultRepository;
+import putBit.app.services.exceptions.EntityNotFoundException;
+import putBit.app.services.exceptions.ValidationException;
+
+import java.util.List;
+
+@Service
+@RequiredArgsConstructor
+public class ExamResultService {
+
+    private final ExamResultRepository examResultRepository;
+    private final UserService userService;
+    private final ExamService examService;
+
+    public ExamResult create(ExamResult examResult){
+
+        if(examResult.getPoints() > 100 || examResult.getPoints() < 0 )
+            throw new ValidationException("Неверные данные");
+
+        User user = userService.findById(examResult.getUser().getId());
+        Exam exam = examService.findById(examResult.getExam().getId());
+        ExamResult newExam = ExamResult.builder()
+                .user(user)
+                .exam(exam)
+                .points(examResult.getPoints())
+                .build();
+        return examResultRepository.save(newExam);
+    }
+
+    public ExamResult findById(int userId, int examId){
+        User user = userService.findById(userId);
+        Exam exam = examService.findById(examId);
+        ExamResultPK pk = new ExamResultPK(user.getId(),exam.getId());
+        return examResultRepository.findById(pk)
+                .orElseThrow(() -> new EntityNotFoundException("Экзамен не найден"));
+    }
+
+    public ExamResult update(ExamResult examResult)
+    {
+        if(examResult.getPoints() > 100 || examResult.getPoints() < 0 )
+            throw new ValidationException("Неверные данные");
+
+        ExamResult currentExam = findById(examResult.getUser().getId(),examResult.getExam().getId());
+
+        currentExam.setPoints(examResult.getPoints());
+        return examResultRepository.save(currentExam);
+    }
+
+    public ExamResult delete(int userId, int examId){
+        ExamResult currentExam = findById( userId,  examId);
+        examResultRepository.delete(currentExam);
+        return currentExam;
+    }
+    public List<ExamResult> findByUser(User user){
+        User currentUser = userService.findById(user.getId());
+        return examResultRepository.findAllByUser(currentUser);
+    }
+}

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

@@ -0,0 +1,65 @@
+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.Training;
+import putBit.app.models.User;
+import putBit.app.models.enums.Role;
+import putBit.app.repositories.ExamRepository;
+import putBit.app.services.exceptions.EntityNotFoundException;
+import putBit.app.services.exceptions.ValidationException;
+
+import java.util.List;
+
+@Service
+@RequiredArgsConstructor
+public class ExamService {
+    private final ExamRepository examRepository;
+
+    public Exam create(Exam exam){
+
+        if(exam.getTitle().isEmpty() || (exam.getTitle().length() < 3 || exam.getTitle().length() > 20  ) )
+            throw new ValidationException("Неверные данные");
+
+        Exam newExam = Exam.builder()
+                .title(exam.getTitle())
+                .build();
+        return examRepository.save(newExam);
+    }
+
+    public Exam findById(int id){
+        return examRepository.findById(id)
+                .orElseThrow(() -> new EntityNotFoundException("Экзамен не найден"));
+    }
+
+    public Exam update(Exam exam)
+    {
+        if(exam.getTitle().isEmpty() || (exam.getTitle().length() < 3 || exam.getTitle().length() > 20  ) )
+            throw new ValidationException("Неверные данные");
+
+        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());
+    }
+
+    public List<Exam> findNotTraining(Training training){
+        return examRepository.findByTrainingIdNot(training.getId());
+    }
+
+}

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

@@ -0,0 +1,92 @@
+package putBit.app.services;
+
+import lombok.RequiredArgsConstructor;
+import org.aspectj.weaver.ast.Or;
+import org.hibernate.service.NullServiceException;
+import org.hibernate.sql.exec.ExecutionException;
+import org.springframework.stereotype.Service;
+import putBit.app.models.*;
+import putBit.app.models.PrimaryKey.OrderPK;
+import putBit.app.repositories.OrderRepository;
+import putBit.app.services.exceptions.EntityNotFoundException;
+
+import java.util.List;
+
+@Service
+@RequiredArgsConstructor
+public class OrderService {
+
+    private final UserService userService;
+    private final TrainingService trainingService;
+    private final OrderRepository orderRepository;
+
+    public Order create(Order order){
+        User user = userService.findById(order.getUser().getId());
+        Training training = trainingService.findById(order.getTraining().getId());
+        int limit = 0;
+        for(TrainingExam exam:
+                training.getExams())
+        {
+            boolean check = false;
+            for(ExamResult result:
+            user.getExams())
+            {
+                if(result.getExam().getId() == exam.getExam().getId())
+                {
+                    check = true;
+                    break;
+                }
+            }
+            if(!check)
+                return null;
+
+        }
+        for(TrainingExam exam:
+        training.getExams())
+        {
+            limit+=exam.getPoints();
+        }
+        int userPoints=0;
+        for(ExamResult result:
+                user.getExams())
+        {
+            userPoints+= result.getPoints();
+        }
+        if(limit>userPoints)
+            return null;
+
+        Order newOrder = Order.builder()
+                .user(user)
+                .training(training)
+                .benefit(user.getBenefits() != null && !user.getBenefits().isEmpty())
+                .confirm(false)
+                .build();
+
+        return  orderRepository.save(newOrder);
+    }
+
+    public Order findById(int userId, int trainId){
+        OrderPK pk = new OrderPK(userId,trainId);
+        return orderRepository.findById(pk)
+                .orElseThrow(() -> new EntityNotFoundException("Заявка не найдена"));
+    }
+
+    public Order delete(int userId, int trainId){
+        Order currentOrder = findById(userId,trainId);
+        orderRepository.delete(currentOrder);
+        return currentOrder;
+
+    }
+
+    public List<Order> findForBenefit(){
+        return orderRepository.findAllByBenefit(true);
+    }
+
+    public List<Order> findForBasic(){
+        return orderRepository.findAllByBenefit(false);
+    }
+
+    public List<Order> findByNameOrSnils(String text){
+        return orderRepository.findByUserInfo(text);
+    }
+}

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

@@ -0,0 +1,65 @@
+package putBit.app.services;
+
+import lombok.RequiredArgsConstructor;
+import org.hibernate.sql.exec.ExecutionException;
+import org.springframework.stereotype.Service;
+import putBit.app.models.*;
+import putBit.app.models.PrimaryKey.TrainingExamPK;
+import putBit.app.repositories.TrainingExamRepository;
+import putBit.app.services.exceptions.EntityNotFoundException;
+import putBit.app.services.exceptions.ValidationException;
+
+import java.util.List;
+
+@Service
+@RequiredArgsConstructor
+public class TrainingExamService {
+    private final TrainingExamRepository trainingExamRepository;
+    private final ExamService examService;
+    private final TrainingService trainingService;
+
+    public TrainingExam create(TrainingExam trainingExam){
+
+        if(trainingExam.getPoints() > 100 || trainingExam.getPoints() < 0 )
+            throw new ValidationException("Неверные данные");
+
+
+
+        Training training = trainingService.findById(trainingExam.getTraining().getId());
+        Exam exam = examService.findById(trainingExam.getExam().getId());
+        TrainingExam newExam = TrainingExam.builder()
+                .training(training)
+                .exam(exam)
+                .points(trainingExam.getPoints())
+                .build();
+        return trainingExamRepository.save(newExam);
+    }
+
+    public TrainingExam findById(int trainId, int examId){
+        TrainingExamPK pk = new TrainingExamPK(trainId,examId);
+        return trainingExamRepository.findById(pk)
+                .orElseThrow(() -> new EntityNotFoundException("Экзамен не найден"));
+    }
+
+    public TrainingExam update(TrainingExam trainingExam)
+    {
+        if(trainingExam.getPoints() > 100 || trainingExam.getPoints() < 0 )
+            throw new ValidationException("Неверные данные");
+
+        TrainingExam currentExam = findById(trainingExam.getTraining().getId(),trainingExam.getExam().getId());
+
+        currentExam.setPoints(trainingExam.getPoints());
+        return trainingExamRepository.save(currentExam);
+    }
+
+    public TrainingExam delete(int trainId, int examId){
+        TrainingExam currentExam = findById( trainId,  examId);
+        trainingExamRepository.delete(currentExam);
+        return currentExam;
+    }
+    public List<TrainingExam> findByTraining(Training training){
+        Training currentTraining = trainingService.findById(training.getId());
+        return trainingExamRepository.findAllByTraining(currentTraining);
+    }
+
+}

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

@@ -0,0 +1,92 @@
+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.Training;
+import putBit.app.models.User;
+import putBit.app.repositories.TrainingRepository;
+import putBit.app.services.exceptions.EntityNotFoundException;
+import putBit.app.services.exceptions.ValidationException;
+
+import java.util.List;
+
+@Service
+@RequiredArgsConstructor
+public class TrainingService {
+    private final TrainingRepository trainingRepository;
+
+    public Training create(Training training){
+
+        if(training.getTitle().isEmpty() || (training.getTitle().length() < 2 || training.getTitle().length() > 50  ) )
+            throw new ValidationException("Неверное название");
+        if(training.getNum().isEmpty() || (training.getNum().length() < 8 || training.getTitle().length() > 11  ) )
+            throw new ValidationException("Неверный номер");
+        if(training.getDesc().isEmpty() || (training.getDesc().length() < 10 || training.getDesc().length() > 300  ) )
+            throw new ValidationException("Неверное описание");
+        if(training.getProf().isEmpty() || (training.getProf().length() < 5 || training.getProf().length() > 300  ) )
+            throw new ValidationException("Неверные профессии");
+        if(training.getBasic_places() > 999 || training.getBasic_places() < 10 )
+            throw new ValidationException("Неверные базовые места");
+        if(training.getBenefit_places() > 999 || training.getBenefit_places() < 10 )
+            throw new ValidationException("Неверные льготные места");
+
+
+        Training newTraining = Training.builder()
+                .title(training.getTitle())
+                .num(training.getNum())
+                .desc(training.getDesc())
+                .prof(training.getProf())
+                .basic_places(training.getBasic_places())
+                .benefit_places(training.getBenefit_places())
+                .build();
+        return trainingRepository.save(newTraining);
+    }
+
+    public Training findById(int id){
+        return trainingRepository.findById(id)
+                .orElseThrow(() -> new EntityNotFoundException("Направление не найдено"));
+    }
+
+    public Training update(Training training)
+    {
+
+        if(training.getTitle().isEmpty() || (training.getTitle().length() < 2 || training.getTitle().length() > 50  ) )
+            throw new ValidationException("Неверное название");
+        if(training.getNum().isEmpty() || (training.getNum().length() < 8 || training.getNum().length() > 11  ) )
+            throw new ValidationException("Неверный номер");
+        if(training.getDesc().isEmpty() || (training.getDesc().length() < 10 || training.getDesc().length() > 300  ) )
+            throw new ValidationException("Неверное описание");
+        if(training.getProf().isEmpty() || (training.getProf().length() < 5 || training.getProf().length() > 300  ) )
+            throw new ValidationException("Неверные профессии");
+        if(training.getBasic_places() > 999 || training.getBasic_places() < 10 )
+            throw new ValidationException("Неверные базовые места");
+        if(training.getBenefit_places() > 999 || training.getBenefit_places() < 10 )
+            throw new ValidationException("Неверные льготные места");
+
+        Training currentTraining = findById(training.getId());
+
+        currentTraining.setTitle(training.getTitle());
+        currentTraining.setNum(training.getNum());
+        currentTraining.setDesc(training.getDesc());
+        currentTraining.setProf(training.getProf());
+        currentTraining.setBasic_places(training.getBasic_places());
+        currentTraining.setBenefit_places(training.getBenefit_places());
+        return trainingRepository.save(currentTraining);
+    }
+
+    public Training delete(Training training){
+        Training currentTraining = findById(training.getId());
+        trainingRepository.delete(currentTraining);
+        return currentTraining;
+    }
+
+    public List<Training> findAll(){
+        return trainingRepository.findAll();
+    }
+
+    public List<Training> findByTitle(String title){
+        return trainingRepository.findAllByTitleContaining(title);
+    }
+}

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

@@ -0,0 +1,115 @@
+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;
+import putBit.app.services.exceptions.EntityNotFoundException;
+import putBit.app.services.exceptions.ValidationException;
+
+@Service
+@RequiredArgsConstructor
+public class UserService {
+    private final UserRepository userRepository;
+
+    private final BenefitService benefitService;
+    private final AchievementService achievementService;
+
+    public User create(User user){
+
+        if(user.getEmail().isEmpty() )
+            throw new ValidationException("Неверная почта");
+        if(user.getName().isEmpty() || (user.getName().length() < 3 || user.getName().length() > 80  ) )
+            throw new ValidationException("Неверное ФИО");
+        if(user.getSnils().length() != 11)
+            throw new ValidationException("Неверный снилс");
+        if(user.getPassword().isEmpty() || (user.getPassword().length() < 6 || user.getName().length() > 20  ) )
+            throw new ValidationException("Неверный пароль");
+        if(user.getPhone().length() != 11)
+            throw new ValidationException("Неверный номер телефона");
+
+
+        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 EntityNotFoundException("Пользователь не найден"));
+    }
+
+    public User auth(User user)
+    {
+        return userRepository.findByEmailAndPassword(user.getEmail(), user.getPassword())
+                .orElseThrow(() -> new EntityNotFoundException("Пользователь не найден"));
+    }
+
+    public User update(User user)
+    {
+        if(user.getEmail().isEmpty() )
+            throw new ValidationException("Неверная почта");
+        if(user.getName().isEmpty() || (user.getName().length() < 3 || user.getName().length() > 80  ) )
+            throw new ValidationException("Неверное ФИО");
+        if(user.getSnils().length() != 11)
+            throw new ValidationException("Неверный снилс");
+        if(user.getPassword().isEmpty() || (user.getPassword().length() < 6 || user.getName().length() > 20  ) )
+            throw new ValidationException("Неверный пароль");
+        if(user.getPhone().length() > 12 || user.getPhone().length() < 11)
+            throw new ValidationException("Неверный номер телефона");
+
+
+        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());
+
+        return userRepository.save(currentUser);
+    }
+    public User addAchievement(User user,Achievement achievement){
+        User currentUser = findById(user.getId());
+        Achievement newAch = achievementService.findById(achievement.getId());
+        currentUser.addAchievement(newAch);
+        return userRepository.save(currentUser);
+    }
+    public User addBenefit(User user,Benefit benefit){
+        User currentUser = findById(user.getId());
+        Benefit newBen = benefitService.findById(benefit.getId());
+        currentUser.addBenefit(newBen);
+        return userRepository.save(currentUser);
+    }
+
+    public User removeAchievement(User user,Achievement achievement){
+        User currentUser = findById(user.getId());
+        Achievement newAch = achievementService.findById(achievement.getId());
+        if (!currentUser.deleteAchievement(newAch))
+            throw new RuntimeException("нет такой ачивки у этого человека");
+        return userRepository.save(currentUser);
+    }
+
+    public User removeBenefit(User user,Benefit benefit){
+        User currentUser = findById(user.getId());
+        Benefit newBen = benefitService.findById(benefit.getId());
+        if (!currentUser.deleteBenefit(newBen))
+            throw new RuntimeException("нет такой ачивки у этого человека");
+        return userRepository.save(currentUser);
+    }
+}

app/src/main/java/putBit/app/services/exceptions/EntityNotFoundException.java

@@ -0,0 +1,7 @@
+package putBit.app.services.exceptions;
+
+public class EntityNotFoundException extends RuntimeException {
+    public EntityNotFoundException(String text) {
+        super(String.format(text));
+    }
+}

app/src/main/java/putBit/app/services/exceptions/ValidationException.java

@@ -0,0 +1,7 @@
+package putBit.app.services.exceptions;
+
+public class ValidationException extends RuntimeException {
+    public ValidationException(String text) {
+        super(String.format(text));
+    }
+}

app/src/main/resources/application.properties

@@ -1 +1,12 @@
 spring.application.name=app
+spring.main.banner-mode=off
+#server.port=8081
+spring.datasource.url=jdbc:h2:file:./data
+spring.datasource.driverClassName=org.h2.Driver
+spring.datasource.username=sa
+spring.datasource.password=password
+spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
+spring.jpa.hibernate.ddl-auto=update
+spring.h2.console.enabled=true
+spring.h2.console.settings.trace=false
+spring.h2.console.settings.web-allow-others=false

app/src/test/java/putBit/app/AppApplicationTests.java

@@ -1,13 +1,433 @@
 package putBit.app;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
+import putBit.app.models.*;
+import putBit.app.models.enums.Role;
+import putBit.app.services.*;
+
+import java.util.ArrayList;
+import java.util.List;
 
 @SpringBootTest
 class AppApplicationTests {
+	@Autowired
+	UserService userService;
+
+	@Autowired
+	ExamService examService;
+
+	@Autowired
+	ExamResultService examResultService;
+
+	@Autowired
+	BenefitService benefitService;
+
+	@Autowired
+	AchievementService achievementService;
+
+	@Autowired
+	TrainingService trainingService;
+
+	@Autowired
+	TrainingExamService trainingExamService;
+
+	@Autowired
+	OrderService orderService;
 
 	@Test
-	void contextLoads() {
+	void createUser() {
+
+		User us1 = User.builder()
+				.email("email1")
+				.password("12345678")
+				.phone("88005553535")
+				.role(Role.USER)
+				.name("Vova Morozov")
+				.snils("33322233344")
+				.build();
+		User us2 = User.builder()
+				.email("email2")
+				.password("12345678")
+				.phone("88005553535")
+				.role(Role.USER)
+				.name("Dima Redov")
+				.snils("11122233344")
+				.build();
+		User res1 = userService.create(us1);
+		User res2 = userService.create(us2);
+		Assertions.assertNotNull(res1);
+		Assertions.assertNotNull(res2);
 	}
 
+	@Test
+	void CreateExam(){
+		Exam ex1 = Exam.builder()
+				.title("Математика")
+				.build();
+		Exam ex2 = Exam.builder()
+				.title("Русский язык")
+				.build();
+		Exam ex3 = Exam.builder()
+				.title("Физика")
+				.build();
+		Exam ex4 = Exam.builder()
+				.title("Информатика")
+				.build();
+
+		Exam res1 = examService.create(ex1);
+		Exam res2 = examService.create(ex2);
+		Exam res3 = examService.create(ex3);
+		Exam res4 = examService.create(ex4);
+
+		Assertions.assertNotNull(res1);
+		Assertions.assertNotNull(res2);
+		Assertions.assertNotNull(res3);
+		Assertions.assertNotNull(res4);
+	}
+
+	@Test
+	void CreateBenefit(){
+		Benefit bf1 = Benefit.builder()
+				.title("Инвалидность I")
+				.build();
+		Benefit bf2 = Benefit.builder()
+				.title("Инвалидность II")
+				.build();
+		Benefit bf3 = Benefit.builder()
+				.title("Инвалидность III")
+				.build();
+
+		Benefit res1 = benefitService.create(bf1);
+		Benefit res2 = benefitService.create(bf2);
+		Benefit res3 = benefitService.create(bf3);
+
+		Assertions.assertNotNull(res1);
+		Assertions.assertNotNull(res2);
+		Assertions.assertNotNull(res3);
+	}
+	@Test
+	void CreateAchievements(){
+		Achievement ac1 = Achievement.builder()
+				.title("ГТО 1 степени")
+				.points(5)
+				.build();
+		Achievement ac2 = Achievement.builder()
+				.title("ГТО 2 степени")
+				.points(3)
+				.build();
+		Achievement ac3 = Achievement.builder()
+				.title("Красный диплом")
+				.points(7)
+				.build();
+
+		Achievement res1 = achievementService.create(ac1);
+		Achievement res2 = achievementService.create(ac2);
+		Achievement res3 = achievementService.create(ac3);
+
+		Assertions.assertNotNull(res1);
+		Assertions.assertNotNull(res2);
+		Assertions.assertNotNull(res3);
+	}
+	@Test
+	void CreateExamResult(){
+
+		User us1 = userService.findById(1);
+		User us2 = userService.findById(52);
+
+		Exam ex1 = examService.findById(1);
+		Exam ex2 = examService.findById(2);
+		Exam ex3 = examService.findById(3);
+
+		ExamResult er1 = ExamResult.builder()
+				.user(us1)
+				.exam(ex1)
+				.points(30)
+				.build();
+		ExamResult er2 = ExamResult.builder()
+				.user(us1)
+				.exam(ex2)
+				.points(30)
+				.build();
+
+		ExamResult er3 = ExamResult.builder()
+				.user(us2)
+				.exam(ex2)
+				.points(50)
+				.build();
+		ExamResult er4 = ExamResult.builder()
+				.user(us2)
+				.exam(ex3)
+				.points(60)
+				.build();
+
+		var res1 = examResultService.create(er1);
+		var res2 = examResultService.create(er2);
+		var res3 = examResultService.create(er3);
+		var res4 = examResultService.create(er4);
+
+		Assertions.assertNotNull(res1);
+		Assertions.assertNotNull(res2);
+		Assertions.assertNotNull(res3);
+		Assertions.assertNotNull(res4);
+	}
+
+	@Test
+	void CreateTraining() {
+		Training tr1 = Training.builder()
+				.title("ПИбд")
+				.num("09.09.01.01")
+				.desc("Типо программисты")
+				.prof("бэкендер, фронтендер, аналитикffff")
+				.basic_places(100)
+				.benefit_places(10)
+				.build();
+		Training tr2 = Training.builder()
+				.title("ИВТ")
+				.num("09.09.02")
+				.desc("Типо программисты-инженеры")
+				.prof("на заваод")
+				.basic_places(120)
+				.benefit_places(12)
+				.build();
+		Training tr3 = Training.builder()
+				.title("ИСЭ")
+				.num("09.09.03")
+				.desc("Типо программисты-инженеры")
+				.prof("цифровой экономист")
+				.basic_places(120)
+				.benefit_places(12)
+				.build();
+
+		var res1 = trainingService.create(tr1);
+		var res2 = trainingService.create(tr2);
+		var res3 = trainingService.create(tr3);
+
+		Assertions.assertNotNull(res1);
+		Assertions.assertNotNull(res2);
+		Assertions.assertNotNull(res3);
+	}
+
+	@Test
+	void CreateTrainingExam(){
+
+		Training tr1 = trainingService.findById(1);
+		Training tr2 = trainingService.findById(2);
+
+		Exam ex1 = examService.findById(1);
+		Exam ex2 = examService.findById(2);
+		Exam ex3 = examService.findById(4);
+
+		TrainingExam te1 = TrainingExam.builder()
+				.training(tr1)
+				.exam(ex1)
+				.points(30)
+				.build();
+		TrainingExam te2 = TrainingExam.builder()
+				.training(tr1)
+				.exam(ex2)
+				.points(30)
+				.build();
+		TrainingExam te3 = TrainingExam.builder()
+				.training(tr2)
+				.exam(ex2)
+				.points(5)
+				.build();
+		TrainingExam te4 = TrainingExam.builder()
+				.training(tr2)
+				.exam(ex3)
+				.points(66)
+				.build();
+
+		var res1 = trainingExamService.create(te1);
+		var res2 = trainingExamService.create(te2);
+		var res3 = trainingExamService.create(te3);
+		var res4 = trainingExamService.create(te4);
+
+		Assertions.assertNotNull(res1);
+		Assertions.assertNotNull(res2);
+		Assertions.assertNotNull(res3);
+		Assertions.assertNotNull(res4);
+
+	}
+	@Test
+	void CreateOrder(){
+		Training tr1 = trainingService.findById(1);
+		Training tr2 = trainingService.findById(3);
+
+		User us1 = userService.findById(2);
+		User us2 = userService.findById(2);
+
+		Order o1 = Order.builder()
+				.user(us1)
+				.training(tr1)
+				.build();
+		Order o2 = Order.builder()
+				.user(us2)
+				.training(tr2)
+				.build();
+
+		var res1 = orderService.create(o1);
+		var res2 = orderService.create(o2);
+
+		Assertions.assertNotNull(res1);
+		Assertions.assertNotNull(res2);
+	}
+
+	@Test
+	void updateUser(){
+		User us1 = userService.findById(1);
+		String oldName = us1.getName();
+		us1.setName(oldName + "Upd");
+		var res = userService.update(us1);
+		Assertions.assertNotNull(res);
+
+	}
+
+	@Test
+	void updateUserAdd(){
+		User us1 = userService.findById(1);
+		Achievement ach1 = achievementService.findById(1);
+		Achievement ach2 = achievementService.findById(2);
+		List<User> res = new ArrayList<>();
+		res.add(userService.addAchievement(us1, ach2));
+		res.add(userService.addAchievement(us1, ach1));
+
+		User us2 = userService.findById(52);
+		Benefit b1 = benefitService.findById(2);
+		Benefit b2 = benefitService.findById(3);
+
+		res.add(userService.addAchievement(us2, ach2));
+		res.add(userService.addBenefit(us2, b2));
+		res.add(userService.addBenefit(us1,b2));
+		Assertions.assertEquals(res.size(),4);
+	}
+
+	@Test
+	void updateUserRemove(){
+		User us1 = userService.findById(52);
+		Benefit b1 = benefitService.findById(3);
+		int countB = us1.getBenefits().size();
+		us1 = userService.removeBenefit(us1,b1);
+		Assertions.assertEquals(countB-1,us1.getBenefits().size());
+	}
+
+	@Test
+	void updateExam(){
+		Exam ex = examService.findById(1);
+		String oldName = ex.getTitle();
+		ex.setTitle(ex.getTitle() + "UPD");
+		var res = examService.update(ex);
+		Assertions.assertEquals(oldName + "UPD", res.getTitle());
+	}
+
+	@Test
+	void updateExamResult(){
+		ExamResult er = examResultService.findById(1,1);
+		er.setPoints(100);
+		var res = examResultService.update(er);
+		Assertions.assertEquals(100,res.getPoints());
+	}
+
+	@Test
+	void updateBenefit(){
+		Benefit b = benefitService.findById(1);
+		String oldName = b.getTitle();
+		b.setTitle(b.getTitle() + "UPD");
+		var res = benefitService.update(b);
+		Assertions.assertEquals(oldName + "UPD", res.getTitle());
+	}
+
+	@Test
+	void updateAchievement(){
+		Achievement b = achievementService.findById(1);
+		String oldName = b.getTitle();
+		b.setTitle(b.getTitle() + "UPD");
+		var res = achievementService.update(b);
+		Assertions.assertEquals(oldName + "UPD", res.getTitle());
+
+	}
+
+	@Test
+	void updateTraining(){
+		Training b = trainingService.findById(1);
+		String oldName = b.getTitle();
+		b.setTitle(b.getTitle() + "UPD");
+		var res = trainingService.update(b);
+		Assertions.assertEquals(oldName + "UPD", res.getTitle());
+
+	}
+
+	@Test
+	void updateTrainigExam(){
+		TrainingExam er = trainingExamService.findById(1,1);
+		er.setPoints(90);
+		var res = trainingExamService.update(er);
+		Assertions.assertEquals(110,res.getPoints());
+
+	}
+
+	@Test
+	void deleteExam(){
+		int countBefore = examService.findAll().size();
+		Exam ex = examService.findById(3);
+		examService.delete(ex);
+		int countAfter = examService.findAll().size();
+		Assertions.assertEquals(countBefore-1,countAfter);
+	}
+
+	@Test
+	void deleteBenefit(){
+		int countBefore = benefitService.findAll().size();
+		Benefit ex = benefitService.findById(3);
+		benefitService.delete(ex);
+		int countAfter = benefitService.findAll().size();
+		Assertions.assertEquals(countBefore-1,countAfter);
+	}
+
+	@Test
+	void deleteAchievement(){
+		int countBefore = achievementService.findAll().size();
+		Achievement ex = achievementService.findById(2);
+		achievementService.delete(ex);
+		int countAfter = achievementService.findAll().size();
+		Assertions.assertEquals(countBefore-1,countAfter);
+	}
+
+	@Test
+	void deleteExamResult(){
+		var res = examResultService.delete(1,1);
+		Assertions.assertEquals(1,res.getUser().getId());
+	}
+
+	@Test
+	void deleteTraining(){
+		int countBefore = trainingService.findAll().size();
+		Training ex = trainingService.findById(2);
+		trainingService.delete(ex);
+		int countAfter = trainingService.findAll().size();
+		Assertions.assertEquals(countBefore-1,countAfter);
+	}
+
+	@Test
+	void deleteTrainingExam(){
+		var res = trainingExamService.delete(1,1);
+		Assertions.assertEquals(1,res.getTraining().getId());
+	}
+
+	@Test
+	void deleteOrder(){
+		var res = orderService.delete(2,3);
+		System.out.println(res.getUser().getName());
+	}
+
+
 }
+
+
+
+
+
+