Changeset e0ef1b1 in Git for src/main/java/com/wediscussmovies/project/service/impl/PersonServiceImpl.java

Timestamp:

02/04/22 23:22:13 (3 years ago)

Author:

Test <matonikolov77@…>

Branches:

main

Children:

5b447b0

Parents:

3ded84d

Message:

Added CRUD for movies,persons,discussion,replies,genres
Added ajaxcalls

File:

• src/main/java/com/wediscussmovies/project/service/impl/PersonServiceImpl.java (modified) (1 diff)

src/main/java/com/wediscussmovies/project/service/impl/PersonServiceImpl.java

@@ -1 +1 @@
 package com.wediscussmovies.project.service.impl;
 
-import com.wediscussmovies.project.model.*;
-import com.wediscussmovies.project.model.enumerations.PersonType;
+import com.wediscussmovies.project.ajaxmodels.Grade;
+import com.wediscussmovies.project.model.Movie;
+import com.wediscussmovies.project.model.User;
+import com.wediscussmovies.project.model.exception.MovieHasAlreadyDirector;
+import com.wediscussmovies.project.model.exception.MovieIdNotFoundException;
+import com.wediscussmovies.project.model.exception.PersonNotExistException;
+import com.wediscussmovies.project.model.primarykeys.PersonRatesPK;
+import com.wediscussmovies.project.model.relation.MovieActors;
+import com.wediscussmovies.project.model.relation.MovieRates;
+import com.wediscussmovies.project.model.relation.PersonRates;
+import com.wediscussmovies.project.repository.MovieActorsRepository;
+import com.wediscussmovies.project.repository.MovieRepository;
+import com.wediscussmovies.project.repository.PersonRatesRepository;
 import com.wediscussmovies.project.repository.PersonRepository;
+import com.wediscussmovies.project.model.Person;
 import com.wediscussmovies.project.service.PersonService;
 import org.springframework.stereotype.Service;
 
+import javax.transaction.Transactional;
+import java.sql.Date;
 import java.util.List;
 import java.util.Optional;
+import java.util.stream.Collectors;
 
 @Service
 public class PersonServiceImpl implements PersonService {
+
     private final PersonRepository personRepository;
+    private final MovieRepository movieRepository;
+    private final MovieActorsRepository movieActorsRepository;
+    private final PersonRatesRepository personRatesRepository;
 
 
-    public PersonServiceImpl(PersonRepository personRepository) {
+    public PersonServiceImpl(PersonRepository personRepository,
+                             MovieRepository movieRepository, MovieActorsRepository movieActorsRepository,
+                             PersonRatesRepository personRatesRepository) {
         this.personRepository = personRepository;
+        this.movieRepository = movieRepository;
+        this.movieActorsRepository = movieActorsRepository;
+        this.personRatesRepository = personRatesRepository;
+    }
+
+    @Override
+    public List<Person> findAll() {
+        return this.personRepository.findAll();
     }
 
     @Override
     public List<Person> findAllDirectors() {
-        return personRepository.findAllByType('D');
+        return this.personRepository.findAllByType('D');
     }
 
     @Override
-    public Optional<Person> findActorById(Integer id) {
-        return personRepository.findPersonByPersonIdAndType(id, 'A');
+    public Person findById(Integer id) {
+        return this.personRepository.findById(id).orElseThrow(() -> new PersonNotExistException(id));
+    }
+
+
+
+    @Override
+    public List<Person> findAllActors() {
+        return this.personRepository.findAllByType('A');
     }
 
     @Override
-    public Optional<Person> findById(Integer person_id) {
-        return personRepository.findById(person_id);
+    @Transactional
+    public Person save(String name, String surname, Character type, Date birthDate, String image_url,
+                       String description,List<Integer> movieIds) {
+
+        Person person = this.personRepository.saveAndFlush(new Person(name,surname,type,birthDate,image_url,description));
+
+        if (movieIds!= null) {
+            if (type.equals('A'))
+                this.addActorForMovies(person, movieIds);
+            else
+                this.addDirectorForMovies(person, movieIds);
+        }
+         return person;
+
     }
 
     @Override
-    public Optional<Person> findDirectorById(Integer id) {
-        return personRepository.findPersonByPersonIdAndType(id, 'D');
+    @Transactional
+    public Person edit(Integer personId, String name, String surname,
+                       Character type, Date birthDate, String image_url, String description, List<Integer> movieIds) {
+        Person person = this.findById(personId);
+
+        person.setName(name);
+        person.setSurname(surname);
+        person.setDateOfBirth(birthDate);
+        person.setImageUrl(image_url);
+        person.setType(type);
+        person.setDescription(description);
+
+
+        person = this.personRepository.saveAndFlush(person);
+
+            this.movieActorsRepository.deleteAllByPerson(person);
+            this.removeMovieDirectorsBeforeEdit(person);
+        if (movieIds != null) {
+            if (type.equals('A'))
+                this.addActorForMovies(person, movieIds);
+            else
+                this.addDirectorForMovies(person, movieIds);
+        }
+
+        return person;
+
     }
 
     @Override
-    public List<Person> findAllActors() {
-        return personRepository.findAllByType('A');
+    public List<Person> findPersonsByNameOrSurname(Character type,String searchQuery) {
+        if (searchQuery != null && searchQuery.isEmpty())
+            return this.personRepository.findAllByTypeAndNameLikeOrSurnameLike(type,searchQuery,searchQuery);
+        if (type.equals('D'))
+            return this.findAllDirectors();
+        return this.findAllActors();
+
     }
 
     @Override
-    public boolean save(Person person) {
-        Person p = personRepository.save(person);
-        if(p != null)
-            return true;
-        return false;
+    public List<Movie> findAllMoviesByPerson(Person person) {
+        if (person.getType().equals('A'))
+            return this.movieActorsRepository
+                .findAllByPerson(person)
+                .stream()
+                .map(MovieActors::getMovie)
+                .collect(Collectors.toList());
+        return this.movieRepository.findAllByDirector(person);
     }
 
     @Override
-    public List<Person> findActorsByNameLike(String name) {
-        return personRepository.findAllByTypeAndNameLike('A', name);
+    public void deleteById(Integer id) {
+        this.personRepository.deleteById(id);
     }
 
     @Override
-    public List<Person> findActorsBySurnameLike(String surname) {
-        return personRepository.findAllByTypeAndSurnameLike('A', surname);
+    public void addGradePerson(Integer personId, User user, Grade grade) {
+        PersonRatesPK key =  new PersonRatesPK(personId, user.getUserId());
+        Optional<PersonRates> personRates = this.personRatesRepository.findById(key);
+        if (personRates.isPresent()){
+            PersonRates rates = personRates.get();
+            rates.setReason(grade.getReason());
+            rates.setStarsRated(grade.getRating());
+            this.personRatesRepository.save(rates);
+        }
+        else{
+            Person person = this.findById(personId);
+            PersonRates rates = new PersonRates(user,person,grade.getReason(),grade.getRating());
+            this.personRatesRepository.save(rates);
+        }
+
     }
 
-    @Override
-    public List<Person> findDirectorsByNameLike(String name) {
-        return personRepository.findAllByTypeAndNameLike('D', name);
+
+    private void addActorForMovies(Person person, List<Integer> movieIds){
+
+        movieIds.stream()
+                .map(this::findMovieById)
+                .forEach(m -> this.movieActorsRepository.save(new MovieActors(m,person)));
+
+    }
+    private void addDirectorForMovies(Person person, List<Integer> movieIds){
+        movieIds.stream()
+                .map(this::findMovieById)
+                .forEach(m -> this.addMovieDirector(m,person));
+    }
+    private void addMovieDirector(Movie movie,Person person){
+        Person director = movie.getDirector();
+        if (director != null)
+            throw new MovieHasAlreadyDirector(movie.getTitle(),director.getName(),director.getSurname());
+        movie.setDirector(person);
+        this.movieRepository.save(movie);
+    }
+    private void removeMovieDirectorsBeforeEdit(Person person){
+        this.movieRepository.findAllByDirector(person)
+                .forEach(m ->{ m.setDirector(null); this.movieRepository.save(m); });
+
     }
 
-    @Override
-    public List<Person> findDirectorsBySurnameLike(String surname) {
-        return personRepository.findAllByTypeAndSurnameLike('D', surname);
+    private Movie findMovieById(Integer id){
+        return this.movieRepository.findById(id).orElseThrow(() -> new MovieIdNotFoundException(id));
     }
+
 }