ЛР4 бэкенд

build.gradle

@@ -17,7 +17,7 @@ dependencies {
 
 	implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
 	implementation 'com.h2database:h2:2.1.210'
-
+	implementation 'org.hibernate.validator:hibernate-validator'
 	implementation group: 'org.springdoc', name: 'springdoc-openapi-ui', version: '1.6.5'
 
 	implementation 'org.springframework.boot:spring-boot-starter-validation'

src/main/java/ru/ulstu/is/lab1/DataBase/Repository/ICollectionRepository.java

@@ -0,0 +1,7 @@
+package ru.ulstu.is.lab1.DataBase.Repository;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import ru.ulstu.is.lab1.DataBase.model.Collection;
+
+public interface ICollectionRepository extends JpaRepository<Collection, Long> {
+}

src/main/java/ru/ulstu/is/lab1/DataBase/Repository/IFilmRepository.java

@@ -0,0 +1,9 @@
+package ru.ulstu.is.lab1.DataBase.Repository;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import ru.ulstu.is.lab1.DataBase.model.Film;
+
+import java.util.List;
+
+public interface IFilmRepository extends JpaRepository<Film, Long> {
+}

src/main/java/ru/ulstu/is/lab1/DataBase/Repository/IGenreRepository.java

@@ -0,0 +1,14 @@
+package ru.ulstu.is.lab1.DataBase.Repository;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import ru.ulstu.is.lab1.DataBase.model.Film;
+import ru.ulstu.is.lab1.DataBase.model.Genre;
+
+import java.util.List;
+
+public interface IGenreRepository extends JpaRepository<Genre, Long> {
+    @Query("SELECT DISTINCT f FROM Film f where :filmsGenres MEMBER OF f.genres")
+    List<Film> findFilmsOnGenre(@Param("filmsGenres") Genre genre);
+}

src/main/java/ru/ulstu/is/lab1/DataBase/controller/CollectionController.java

@@ -12,6 +12,8 @@ import org.springframework.web.bind.annotation.RestController;
 import ru.ulstu.is.lab1.DataBase.model.Collection;
 import ru.ulstu.is.lab1.DataBase.service.CollectionService;
 
+import java.io.IOException;
+import java.util.ArrayList;
 import java.util.List;
 
 @RestController
@@ -25,37 +27,59 @@ public class CollectionController {
     }
 
     @GetMapping("/{id}")
-    public Collection getCollection(@PathVariable Long id) {
-        return collectionService.findCollection(id);
+    public CollectionDTO getCollection(@PathVariable Long id) {
+        return new CollectionDTO(collectionService.findCollection(id));
     }
 
-    @GetMapping("/")
-    public List<Collection> getCollection() {
-        return collectionService.findAllCollections();
+    @GetMapping
+    public List<CollectionDTO> getCollection() {
+        return collectionService.findAllCollections().stream().map(CollectionDTO::new).toList();
     }
 
-    @PostMapping("/")
-    public Collection createCollection(@RequestParam("name") String name) {
-        return collectionService.addCollection(name);
+    @PostMapping
+    public CollectionDTO createCollection(@RequestParam("name") String name, @RequestParam("FilmsId") String FilmsId) throws IOException {
+        List<Long> ids = new ArrayList<>();
+        String num = "";
+        if(FilmsId.length() == 0)
+            FilmsId = "";
+        for (Character sm:
+                FilmsId.toCharArray()) {
+            if(sm.equals('-'))
+            {
+                ids.add(Long.parseLong(num));
+                num="";
+            }
+            else
+                num+=sm;
+        }
+        return new CollectionDTO(collectionService.addCollection(name, ids));
     }
 
     @PatchMapping("/{id}")
-    public Collection updateCollection(@PathVariable Long id, @RequestParam("name") String name) {
-        return collectionService.updateCollection(id, name);
+    public CollectionDTO updateCollection(@PathVariable Long id, @RequestParam("name") String name, @RequestParam("FilmsId") String FilmsId) {
+        List<Long> ids = new ArrayList<>();
+        String num = "";
+        if(FilmsId.length() == 0)
+            FilmsId = "";
+        for (Character sm:
+                FilmsId.toCharArray()) {
+            if(sm.equals('-'))
+            {
+                ids.add(Long.parseLong(num));
+                num="";
             }
-
-    @PatchMapping("/add_film/{id}")
-    public Collection addFilm(@PathVariable Long id, @RequestParam Long film_id) {
-        return collectionService.addFilm(id, film_id);
+            else
+                num+=sm;
         }
-
-    @DeleteMapping("/remove_film/{id}")
-    public Collection removeFilm(@PathVariable Long id, @RequestParam Long film_id) {
-        return collectionService.removeFilm(id, film_id);
+        return new CollectionDTO(collectionService.updateCollection(id, name, ids));
     }
 
     @DeleteMapping("/{id}")
-    public Collection deleteCollection(@PathVariable Long id) {
-        return collectionService.deleteCollection(id);
+    public CollectionDTO deleteCollection(@PathVariable Long id) {
+        return new CollectionDTO(collectionService.deleteCollection(id));
+    }
+    @DeleteMapping
+    public void deleteAllCollections(){
+        collectionService.deleteAllCollections();
     }
 }

src/main/java/ru/ulstu/is/lab1/DataBase/controller/CollectionDTO.java

@@ -0,0 +1,30 @@
+package ru.ulstu.is.lab1.DataBase.controller;
+
+import ru.ulstu.is.lab1.DataBase.model.Collection;
+
+import java.util.List;
+
+public class CollectionDTO {
+    private Long id;
+    private String name;
+    private List<FilmDTO> filmDTOList;
+    public CollectionDTO(Collection collection){
+        this.id = collection.getId();
+        this.name = collection.getName();
+        this.filmDTOList = collection.getFilms() == null ? null : collection.getFilms()
+                .stream()
+                .map(FilmDTO::new)
+                .toList();
+    }
+    public CollectionDTO() {
+    }
+    public Long getId(){
+        return id;
+    }
+    public String getName(){
+        return name;
+    }
+    public List<FilmDTO> getFilmDTOList(){
+        return filmDTOList;
+    }
+}

src/main/java/ru/ulstu/is/lab1/DataBase/controller/FilmController.java

@@ -12,6 +12,8 @@ import org.springframework.web.bind.annotation.RestController;
 import ru.ulstu.is.lab1.DataBase.model.Film;
 import ru.ulstu.is.lab1.DataBase.service.FilmService;
 
+import java.io.IOException;
+import java.util.ArrayList;
 import java.util.List;
 
 @RestController
@@ -24,41 +26,61 @@ public class FilmController {
         this.filmService = filmService;
     }
 
-    @GetMapping("/test")
-    public String test() { return "Test request"; }
-
     @GetMapping("/{id}")
-    public Film getFilm(@PathVariable Long id) {
-        return filmService.findFilm(id);
+    public FilmDTO getFilm(@PathVariable Long id) {
+        return new FilmDTO(filmService.findFilm(id));
     }
 
-    @GetMapping("/")
-    public List<Film> getFilm() {
-        return filmService.findAllFilms();
+    @GetMapping
+    public List<FilmDTO> getFilm() {
+        return filmService.findAllFilms().stream().map(FilmDTO::new).toList();
     }
 
-    @PostMapping("/")
-    public Film createFilm(@RequestParam("name") String name) {
-        return filmService.addFilm(name);
+    @PostMapping
+    public FilmDTO createFilm(@RequestParam("name") String name, @RequestParam("GenresId") String GenresId) throws IOException {
+        List<Long> ids = new ArrayList<>();
+        String num = "";
+        if(GenresId.length() == 0)
+            GenresId = "";
+        for (Character sm:
+                GenresId.toCharArray()) {
+            if(sm.equals('-'))
+            {
+                ids.add(Long.parseLong(num));
+                num="";
+            }
+            else
+                num+=sm;
+        }
+        return new FilmDTO(filmService.addFilm(name, ids));
     }
 
     @PatchMapping("/{id}")
-    public Film updateFilm(@PathVariable Long id, @RequestParam("name") String name) {
-        return filmService.updateFilm(id, name);
+    public FilmDTO updateFilm(@PathVariable Long id, @RequestParam("name") String name,  @RequestParam("GenresId") String GenresId) {
+        List<Long> ids = new ArrayList<>();
+        String num = "";
+        if(GenresId.length() == 0)
+            GenresId = "";
+        for (Character sm:
+                GenresId.toCharArray()) {
+            if(sm.equals('-'))
+            {
+                ids.add(Long.parseLong(num));
+                num="";
             }
-
-    @PatchMapping("/add_genre/{id}")
-    public Film addGenre(@PathVariable Long id, @RequestParam Long genre_id) {
-        return filmService.addGenre(id, genre_id);
+            else
+                num+=sm;
         }
-
-    @DeleteMapping("/remove_genre/{id}")
-    public Film removeGenre(@PathVariable Long id, @RequestParam Long genre_id) {
-        return filmService.removeGenre(id, genre_id);
+        return new FilmDTO(filmService.updateFilm(id, name, ids));
     }
 
     @DeleteMapping("/{id}")
-    public Film deleteFilm(@PathVariable Long id) {
-        return filmService.deleteFilm(id);
+    public FilmDTO deleteFilm(@PathVariable Long id) {
+        return new FilmDTO(filmService.deleteFilm(id));
+    }
+
+    @DeleteMapping
+    public void deleteAllFilms(){
+        filmService.deleteAllFilms();
     }
 }

src/main/java/ru/ulstu/is/lab1/DataBase/controller/FilmDTO.java

@@ -0,0 +1,31 @@
+package ru.ulstu.is.lab1.DataBase.controller;
+
+import ru.ulstu.is.lab1.DataBase.model.Film;
+
+import java.util.List;
+
+public class FilmDTO {
+    private Long id;
+    private String name;
+    private List<GenreDTO> genreDTOList;
+    private List<CollectionDTO> collectionDTOList;
+    public FilmDTO(Film film){
+        this.id = film.getId();
+        this.name = film.getName();
+        this.genreDTOList = film.getGenres() == null ? null : film.getGenres()
+                .stream()
+                .map(GenreDTO::new)
+                .toList();
+    }
+    public FilmDTO() {
+    }
+    public Long getId(){
+        return id;
+    }
+    public String getName(){
+        return name;
+    }
+    public List<GenreDTO> getGenreDTOList(){
+        return genreDTOList;
+    }
+}

src/main/java/ru/ulstu/is/lab1/DataBase/controller/GenreController.java

@@ -25,27 +25,40 @@ public class GenreController {
     }
 
     @GetMapping("/{id}")
-    public Genre getGenre(@PathVariable Long id) {
-        return genreService.findGenre(id);
+    public GenreDTO getGenre(@PathVariable Long id) {
+        return new GenreDTO(genreService.findGenre(id));
     }
 
-    @GetMapping("/")
-    public List<Genre> getGenre() {
-        return genreService.findAllGenres();
+    @GetMapping
+    public List<GenreDTO> getGenre() {
+        return genreService.findAllGenres().stream().map(GenreDTO::new).toList();
     }
 
-    @PostMapping("/")
-    public Genre createGenre(@RequestParam("name") String name) {
-        return genreService.addGenre(name);
+    @PostMapping
+    public GenreDTO createGenre(@RequestParam("name") String name) {
+        return new GenreDTO(genreService.addGenre(name));
     }
 
     @PatchMapping("/{id}")
-    public Genre updateGenre(@PathVariable Long id, @RequestParam("name") String name) {
-        return genreService.updateGenre(id, name);
+    public GenreDTO updateGenre(@PathVariable Long id, @RequestParam("name") String name) {
+        return new GenreDTO(genreService.updateGenre(id, name));
     }
 
     @DeleteMapping("/{id}")
-    public Genre deleteGenre(@PathVariable Long id) {
-        return genreService.deleteGenre(id);
+    public GenreDTO deleteGenre(@PathVariable Long id) {
+        return new GenreDTO(genreService.deleteGenre(id));
+    }
+
+    @DeleteMapping
+    public void deleteAllGenres(){
+        genreService.deleteAllGenres();
+    }
+
+    @GetMapping("/film/{id}")
+    public List<FilmDTO> findFilmOnGenre(@PathVariable Long id){
+        return genreService.findFilmOnGenre(id)
+                .stream()
+                .map(FilmDTO::new)
+                .toList();
     }
 }

src/main/java/ru/ulstu/is/lab1/DataBase/controller/GenreDTO.java

@@ -0,0 +1,20 @@
+package ru.ulstu.is.lab1.DataBase.controller;
+
+import ru.ulstu.is.lab1.DataBase.model.Genre;
+
+public class GenreDTO {
+    private Long id;
+    private String name;
+    public GenreDTO(Genre genre){
+        this.id = genre.getId();
+        this.name = genre.getName();
+    }
+    public GenreDTO() {
+    }
+    public Long getId(){
+        return id;
+    }
+    public String getName(){
+        return name;
+    }
+}

src/main/java/ru/ulstu/is/lab1/DataBase/model/Collection.java

@@ -1,6 +1,7 @@
 package ru.ulstu.is.lab1.DataBase.model;
 
 import javax.persistence.*;
+import javax.validation.constraints.NotBlank;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -11,6 +12,7 @@ public class Collection {
     @Id
     @GeneratedValue(strategy = GenerationType.AUTO)
     private Long id;
+    @NotBlank(message = "Name can't be null")
     private String name;
     @ManyToMany(fetch = FetchType.EAGER)
     @JoinTable(name="collections_films",
@@ -44,7 +46,7 @@ public class Collection {
         }
         if (!this.films.contains(film)) {
             this.films.add(film);
-            film.addCollections(this);
+            film.addCollection(this);
         }
     }
 
@@ -52,6 +54,7 @@ public class Collection {
     public void removeFilm(Film film){
         if(films != null){
             films.remove(film);
+            film.removeCollection(this);
         }
     }
 
@@ -59,6 +62,10 @@ public class Collection {
         return films;
     }
 
+    public void setFilms(List<Film> films) {
+        this.films = films;
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;

src/main/java/ru/ulstu/is/lab1/DataBase/model/Film.java

@@ -4,6 +4,7 @@ import org.hibernate.annotations.LazyCollection;
 import org.hibernate.annotations.LazyCollectionOption;
 
 import javax.persistence.*;
+import javax.validation.constraints.NotBlank;
 
 import java.util.List;
 import java.util.ArrayList;
@@ -14,6 +15,7 @@ public class Film {
     @Id
     @GeneratedValue(strategy = GenerationType.AUTO)
     private Long id;
+    @NotBlank(message = "Name can't be null")
     private String name;
     @ManyToMany
     @LazyCollection(LazyCollectionOption.FALSE)
@@ -58,18 +60,31 @@ public class Film {
         }
     }
 
+    public void addCollection(Collection collection) {
+        if(this.collections==null)
+            collections=new ArrayList<>();
+        if (!this.genres.contains(collection))
+            this.collections.add(collection);
+    }
+
+    public void removeCollection(Collection collection){
+        if(collections != null){
+            collections.remove(collection);
+        }
+    }
+
     public List<Genre> getGenres() {
         return genres;
     }
+    public void setGenres(List<Genre> genres) {
+        this.genres = genres;
+    }
 
     public List<Collection> getCollections() {
         return collections;
     }
-
-    public void addCollections(Collection collection) {
-        if(this.collections==null)
-            collections=new ArrayList<>();
-        collections.add(collection);
+    public void setCollections(List<Collection> collections) {
+        this.collections = collections;
     }
 
     @Override

src/main/java/ru/ulstu/is/lab1/DataBase/model/Genre.java

@@ -1,6 +1,7 @@
 package ru.ulstu.is.lab1.DataBase.model;
 
 import javax.persistence.*;
+import javax.validation.constraints.NotBlank;
 
 import java.util.List;
 import java.util.Objects;
@@ -10,6 +11,7 @@ public class Genre {
     @Id
     @GeneratedValue(strategy = GenerationType.AUTO)
     private Long id;
+    @NotBlank(message = "Name can't be null")
     private String name;
 
     public Genre() {

src/main/java/ru/ulstu/is/lab1/DataBase/service/CollectionNotFoundException.java

@@ -0,0 +1,7 @@
+package ru.ulstu.is.lab1.DataBase.service;
+
+public class CollectionNotFoundException extends RuntimeException {
+    public CollectionNotFoundException(Long id) {
+        super(String.format("Collection with id [%s] is not found", id));
+    }
+}

src/main/java/ru/ulstu/is/lab1/DataBase/service/CollectionService.java

@@ -1,93 +1,81 @@
 package ru.ulstu.is.lab1.DataBase.service;
 
+import ru.ulstu.is.lab1.DataBase.model.Film;
 import ru.ulstu.is.lab1.DataBase.model.Collection;
-import javax.persistence.EntityManager;
-import javax.persistence.EntityNotFoundException;
-import javax.persistence.PersistenceContext;
+import ru.ulstu.is.lab1.DataBase.Repository.ICollectionRepository;
+import ru.ulstu.is.lab1.DataBase.model.Genre;
+import ru.ulstu.is.lab1.util.validation.ValidatorUtil;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
-import org.springframework.util.StringUtils;
-import ru.ulstu.is.lab1.DataBase.model.Film;
-import ru.ulstu.is.lab1.DataBase.model.Genre;
 
+import java.io.IOException;
 import java.util.List;
+import java.util.Optional;
 
 @Service
 public class CollectionService {
-    @PersistenceContext
-    private EntityManager em;
+    private final ICollectionRepository collectionRepository;
+    private final ValidatorUtil validatorUtil;
+    private final FilmService filmService;
 
-    @Transactional
-    public Collection addCollection(String name) {
-        if (!StringUtils.hasText(name)) {
-            throw new IllegalArgumentException("Collection name is null or empty");
+    public CollectionService(ICollectionRepository collectionRepository, ValidatorUtil validatorUtil, FilmService filmService){
+        this.collectionRepository = collectionRepository;
+        this.validatorUtil = validatorUtil;
+        this.filmService = filmService;
     }
+    @Transactional
+    public Collection addCollection(String name, List<Long> filmsId) throws IOException {
         final Collection collection = new Collection(name);
-        em.persist(collection);
-        return collection;
-    }
-
-    @Transactional
-    public Collection addFilm(Long collectionId, Long filmId) {
-        final Collection collection = em.find(Collection.class, collectionId);
-        if (collection == null) {
-            throw new EntityNotFoundException(String.format("Film with id [%s] is not found", collectionId));
-        }
-
-        final Film film = em.find(Film.class, filmId);
-        if (film == null) {
-            throw new EntityNotFoundException(String.format("Genre with id [%s] is not found", filmId));
-        }
-
+        if(filmsId.size() > 0 )
+        {
+            for (Long id: filmsId) {
+                Film film = filmService.findFilm(id);
                 collection.addFilm(film);
-        return em.merge(collection);
             }
+        }
+        validatorUtil.validate(collection);
 
-    @Transactional
-    public Collection removeFilm(Long collectionId, Long filmId){
-        final Collection collection = em.find(Collection.class, collectionId);
-        final Film film = em.find(Film.class, filmId);
-        if(filmId <= 0 || film == null){
-            throw new IllegalArgumentException("Film with id [%s] is not found");
-        }
-        collection.removeFilm(film);
-        return em.merge(collection);
+        return collectionRepository.save(collection);
     }
 
     @Transactional(readOnly = true)
     public Collection findCollection(Long id) {
-        final Collection collection = em.find(Collection.class, id);
-        if (collection == null) {
-            throw new EntityNotFoundException(String.format("Collection with id [%s] is not found", id));
-        }
-        return collection;
+        final Optional<Collection> collection = collectionRepository.findById(id);
+        return collection.orElseThrow(() -> new CollectionNotFoundException(id));
     }
 
     @Transactional(readOnly = true)
     public List<Collection> findAllCollections() {
-        return em.createQuery("select c from Collection c", Collection.class)
-                .getResultList();
+        return collectionRepository.findAll();
     }
 
     @Transactional
-    public Collection updateCollection(Long id, String name) {
-        if (!StringUtils.hasText(name)) {
-            throw new IllegalArgumentException("Collection name is null or empty");
-        }
+    public Collection updateCollection(Long id, String name, List<Long> filmsId) {
         final Collection currentCollection = findCollection(id);
         currentCollection.setName(name);
-        return em.merge(currentCollection);
+        if(filmsId.size()>0)
+        {
+            currentCollection.getFilms().clear();
+            for (Long filmId: filmsId) {
+                Film film = filmService.findFilm(filmId);
+                currentCollection.addFilm(film);
+            }
+        }
+        else
+            currentCollection.getFilms().clear();
+        validatorUtil.validate(currentCollection);
+        return collectionRepository.save(currentCollection);
     }
 
     @Transactional
     public Collection deleteCollection(Long id) {
         final Collection currentCollection = findCollection(id);
-        em.remove(currentCollection);
+        collectionRepository.delete(currentCollection);
         return currentCollection;
     }
 
     @Transactional
     public void deleteAllCollections() {
-        em.createQuery("delete from Collection").executeUpdate();
+        collectionRepository.deleteAll();
     }
 }

src/main/java/ru/ulstu/is/lab1/DataBase/service/FilmNotFoundException.java

@@ -0,0 +1,7 @@
+package ru.ulstu.is.lab1.DataBase.service;
+
+public class FilmNotFoundException extends RuntimeException {
+    public FilmNotFoundException(Long id) {
+        super(String.format("Film with id [%s] is not found", id));
+    }
+}

src/main/java/ru/ulstu/is/lab1/DataBase/service/FilmService.java

@@ -1,103 +1,81 @@
 package ru.ulstu.is.lab1.DataBase.service;
 
-import ru.ulstu.is.lab1.DataBase.model.Film;
 import ru.ulstu.is.lab1.DataBase.model.Genre;
-import javax.persistence.EntityManager;
-import javax.persistence.EntityNotFoundException;
-import javax.persistence.PersistenceContext;
+import ru.ulstu.is.lab1.DataBase.model.Film;
+import ru.ulstu.is.lab1.DataBase.Repository.IFilmRepository;
+import ru.ulstu.is.lab1.util.validation.ValidatorUtil;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
-import org.springframework.util.StringUtils;
 
-import java.math.BigInteger;
-import java.util.ArrayList;
+import java.io.IOException;
 import java.util.List;
+import java.util.Optional;
 
 @Service
 public class FilmService {
-    @PersistenceContext
-    private EntityManager em;
+    private final IFilmRepository filmRepository;
+    private final ValidatorUtil validatorUtil;
+    private final GenreService genreService;
+
+    public FilmService(IFilmRepository filmRepository, ValidatorUtil validatorUtil, GenreService genreService){
+        this.filmRepository = filmRepository;
+        this.validatorUtil = validatorUtil;
+        this.genreService = genreService;
+    }
 
     @Transactional
-    public Film addFilm(String name) {
-        if (!StringUtils.hasText(name)) {
-            throw new IllegalArgumentException("Film name is null or empty");
-        }
+    public Film addFilm(String name, List<Long> genresId) throws IOException {
         final Film film = new Film(name);
-        em.persist(film);
-        return film;
-    }
-
-    @Transactional
-    public Film addGenre(Long filmId, Long genreId) {
-        final Film film = em.find(Film.class, filmId);
-        if (film == null) {
-            throw new EntityNotFoundException(String.format("Film with id [%s] is not found", filmId));
-        }
-
-        final Genre genre = em.find(Genre.class, genreId);
-        if (genre == null) {
-            throw new EntityNotFoundException(String.format("Genre with id [%s] is not found", genreId));
-        }
-
+        if(genresId.size() > 0 )
+        {
+            for (Long id: genresId) {
+                Genre genre = genreService.findGenre(id);
                 film.addGenre(genre);
-        return em.merge(film);
             }
+        }
+        validatorUtil.validate(film);
 
-    @Transactional
-    public Film removeGenre(Long filmId, Long genreId){
-        final Film film = em.find(Film.class, filmId);
-        final Genre genre = em.find(Genre.class, genreId);
-        if(genreId <= 0 || genre == null){
-            throw new IllegalArgumentException("Genre with id [%s] is not found");
-        }
-        film.removeGenre(genre);
-        return em.merge(film);
+        return filmRepository.save(film);
     }
 
     @Transactional(readOnly = true)
     public Film findFilm(Long id) {
-        final Film film = em.find(Film.class, id);
-        if (film == null) {
-            throw new EntityNotFoundException(String.format("Film with id [%s] is not found", id));
-        }
-        return film;
+        final Optional<Film> film = filmRepository.findById(id);
+        return film.orElseThrow(() -> new FilmNotFoundException(id));
     }
 
     @Transactional(readOnly = true)
     public List<Film> findAllFilms() {
-        return em.createQuery("select f from Film f", Film.class)
-                .getResultList();
+        return filmRepository.findAll();
     }
 
     @Transactional
-    public Film updateFilm(Long id, String name) {
-        if (!StringUtils.hasText(name)) {
-            throw new IllegalArgumentException("Film name is null or empty");
-        }
+    public Film updateFilm(Long id, String name, List<Long> genresId) {
         final Film currentFilm = findFilm(id);
         currentFilm.setName(name);
-        return em.merge(currentFilm);
+        if(genresId.size()>0)
+        {
+            currentFilm.getGenres().clear();
+            for (Long genreId: genresId) {
+                Genre genre = genreService.findGenre(genreId);
+                currentFilm.addGenre(genre);
+            }
+        }
+        else
+            currentFilm.getGenres().clear();
+        validatorUtil.validate(currentFilm);
+        return filmRepository.save(currentFilm);
     }
 
     @Transactional
     public Film deleteFilm(Long id) {
         final Film currentFilm = findFilm(id);
-        em.remove(currentFilm);
+        filmRepository.delete(currentFilm);
         return currentFilm;
     }
 
     @Transactional
     public void deleteAllFilms() {
-        em.createQuery("delete from Film").executeUpdate();
-    }
-
-    //сделать запрос отбора фильмов по жанру
-    @Transactional
-    public List<Film> findFilmOnGenre(Genre genre){
-        List filmList = em.createQuery("SELECT DISTINCT f FROM Film f where :filmsGenres MEMBER OF f.genres")
-                .setParameter("filmsGenres", genre)
-                .getResultList();
-        return filmList;
+        filmRepository.deleteAll();
     }
 }

src/main/java/ru/ulstu/is/lab1/DataBase/service/GenreNotFoundException.java

@@ -0,0 +1,7 @@
+package ru.ulstu.is.lab1.DataBase.service;
+
+public class GenreNotFoundException extends RuntimeException {
+    public GenreNotFoundException(Long id) {
+        super(String.format("Genre with id [%s] is not found", id));
+    }
+}

src/main/java/ru/ulstu/is/lab1/DataBase/service/GenreService.java

@@ -1,64 +1,63 @@
 package ru.ulstu.is.lab1.DataBase.service;
 
+import ru.ulstu.is.lab1.DataBase.model.Film;
 import ru.ulstu.is.lab1.DataBase.model.Genre;
-import javax.persistence.EntityManager;
-import javax.persistence.EntityNotFoundException;
-import javax.persistence.PersistenceContext;
+import ru.ulstu.is.lab1.DataBase.Repository.IGenreRepository;
+import ru.ulstu.is.lab1.util.validation.ValidatorUtil;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
-import org.springframework.util.StringUtils;
 
 import java.util.List;
+import java.util.Optional;
 
 @Service
 public class GenreService {
-    @PersistenceContext
-    private EntityManager em;
+    private final IGenreRepository genreRepository;
+    private final ValidatorUtil validatorUtil;
+    public GenreService(IGenreRepository genreRepository, ValidatorUtil validatorUtil){
+        this.genreRepository = genreRepository;
+        this.validatorUtil = validatorUtil;
+    }
 
     @Transactional
     public Genre addGenre(String name) {
-        if (!StringUtils.hasText(name)) {
-            throw new IllegalArgumentException("Genre name is null or empty");
-        }
         final Genre genre = new Genre(name);
-        em.persist(genre);
-        return genre;
+        validatorUtil.validate(genre);
+        return genreRepository.save(genre);
     }
 
     @Transactional(readOnly = true)
     public Genre findGenre(Long id) {
-        final Genre genre = em.find(Genre.class, id);
-        if (genre == null) {
-            throw new EntityNotFoundException(String.format("Genre with id [%s] is not found", id));
-        }
-        return genre;
+        final Optional<Genre> genre = genreRepository.findById(id);
+        return genre.orElseThrow(() -> new GenreNotFoundException(id));
     }
 
     @Transactional(readOnly = true)
     public List<Genre> findAllGenres() {
-        return em.createQuery("select g from Genre g", Genre.class)
-                .getResultList();
+        return genreRepository.findAll();
     }
 
     @Transactional
     public Genre updateGenre(Long id, String name) {
-        if (!StringUtils.hasText(name)) {
-            throw new IllegalArgumentException("Genre name is null or empty");
-        }
         final Genre currentGenre = findGenre(id);
         currentGenre.setName(name);
-        return em.merge(currentGenre);
+        validatorUtil.validate(currentGenre);
+        return genreRepository.save(currentGenre);
     }
 
     @Transactional
     public Genre deleteGenre(Long id) {
         final Genre currentGenre = findGenre(id);
-        em.remove(currentGenre);
+        genreRepository.delete(currentGenre);
         return currentGenre;
     }
 
     @Transactional
     public void deleteAllGenres() {
-        em.createQuery("delete from Genre").executeUpdate();
+        genreRepository.deleteAll();
+    }
+    @Transactional
+    public List<Film> findFilmOnGenre(Long id){
+        return genreRepository.findFilmsOnGenre(findGenre(id));
     }
 }

src/main/java/ru/ulstu/is/lab1/util/error/AdviceController.java

@@ -0,0 +1,43 @@
+package ru.ulstu.is.lab1.util.error;
+
+import org.springframework.context.support.DefaultMessageSourceResolvable;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+
+import ru.ulstu.is.lab1.DataBase.service.GenreNotFoundException;
+import ru.ulstu.is.lab1.DataBase.service.FilmNotFoundException;
+import ru.ulstu.is.lab1.DataBase.service.CollectionNotFoundException;
+import ru.ulstu.is.lab1.util.validation.ValidationException;
+
+import java.util.stream.Collectors;
+
+@ControllerAdvice
+public class AdviceController {
+    @ExceptionHandler({
+            GenreNotFoundException.class,
+            FilmNotFoundException.class,
+            CollectionNotFoundException.class,
+            ValidationException.class
+    })
+    public ResponseEntity<Object> handleException(Throwable e) {
+        return new ResponseEntity<>(e.getMessage(), HttpStatus.BAD_REQUEST);
+    }
+
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public ResponseEntity<Object> handleBindException(MethodArgumentNotValidException e) {
+        final ValidationException validationException = new ValidationException(
+                e.getBindingResult().getAllErrors().stream()
+                        .map(DefaultMessageSourceResolvable::getDefaultMessage)
+                        .collect(Collectors.toSet()));
+        return handleException(validationException);
+    }
+
+    @ExceptionHandler(Exception.class)
+    public ResponseEntity<Object> handleUnknownException(Throwable e) {
+        e.printStackTrace();
+        return new ResponseEntity<>(e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+}

src/main/java/ru/ulstu/is/lab1/util/validation/ValidationException.java

@@ -0,0 +1,9 @@
+package ru.ulstu.is.lab1.util.validation;
+
+import java.util.Set;
+
+public class ValidationException extends RuntimeException{
+    public ValidationException(Set<String> errors) {
+        super(String.join("\n", errors));
+    }
+}

src/main/java/ru/ulstu/is/lab1/util/validation/ValidatorUtil.java

@@ -0,0 +1,29 @@
+package ru.ulstu.is.lab1.util.validation;
+
+import org.springframework.stereotype.Component;
+
+import javax.validation.ConstraintViolation;
+import javax.validation.Validation;
+import javax.validation.Validator;
+import javax.validation.ValidatorFactory;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class ValidatorUtil{
+    private final Validator validator;
+
+    public ValidatorUtil() {
+        try (ValidatorFactory factory = Validation.buildDefaultValidatorFactory()) {
+            this.validator = factory.getValidator();
+        }
+    }
+
+    public <T> void validate(T object) {
+        final Set<ConstraintViolation<T>> errors = validator.validate(object);
+        if (!errors.isEmpty()) {
+            throw new ValidationException(errors.stream()
+                    .map(ConstraintViolation::getMessage)
+                    .collect(Collectors.toSet()));
+        }
+    }
+}

src/test/java/ru/ulstu/is/lab1/JpaCollectionTests.java

@@ -18,7 +18,7 @@ import java.util.List;
 
 @SpringBootTest
 public class JpaCollectionTests {
-    private static final Logger log = LoggerFactory.getLogger(JpaFilmTests.class);
+    /*private static final Logger log = LoggerFactory.getLogger(JpaFilmTests.class);
     @Autowired
     private CollectionService collectionService;
     @Autowired
@@ -76,5 +76,5 @@ public class JpaCollectionTests {
         final List<Collection> collections = collectionService.findAllCollections();
         log.info("testCollectionReadAllEmpty: " + collections.toString());
         Assertions.assertEquals(collections.size(), 0);
-    }
+    }*/
 }

src/test/java/ru/ulstu/is/lab1/JpaFilmTests.java

@@ -17,7 +17,7 @@ import java.util.List;
 
 @SpringBootTest
 public class JpaFilmTests {
-    private static final Logger log = LoggerFactory.getLogger(JpaFilmTests.class);
+    /*private static final Logger log = LoggerFactory.getLogger(JpaFilmTests.class);
     @Autowired
     private FilmService filmService;
     @Autowired
@@ -92,5 +92,5 @@ public class JpaFilmTests {
         List<Film> list = filmService.findFilmOnGenre(genre1);
         log.info("findFilmOnGenre: " + list.toString());
         Assertions.assertEquals(list.size(), 2);
-    }
+    }*/
 }

src/test/java/ru/ulstu/is/lab1/JpaGenreTests.java

@@ -14,7 +14,7 @@ import java.util.List;
 
 @SpringBootTest
 class JpaGenreTests {
-    private static final Logger log = LoggerFactory.getLogger(JpaGenreTests.class);
+    /*private static final Logger log = LoggerFactory.getLogger(JpaGenreTests.class);
     @Autowired
     private GenreService genreService;
     @Test
@@ -57,5 +57,5 @@ class JpaGenreTests {
         final List<Genre> genres = genreService.findAllGenres();
         log.info("testGenreReadAllEmpty: " + genres.toString());
         Assertions.assertEquals(genres.size(), 0);
-    }
+    }*/
 }