Функциональность «Общие фильмы».

src/main/java/ru/yandex/practicum/filmorate/controller/FilmController.java

@@ -48,6 +48,14 @@ public FilmDto removeLike(@PathVariable long id, @PathVariable long userId) {
         return filmService.removeLike(id, userId);
     }
 
+    @GetMapping("/common")
+    public Collection<FilmDto> getCommonFilms(
+            @RequestParam long userId,
+            @RequestParam long friendId) {
+        return filmService.getCommonFilms(userId, friendId);
+
+    }
+
     @GetMapping("/popular")
     public Collection<FilmDto> getMostPopularFilms(@RequestParam(required = false, defaultValue = "10") int count) {
         return filmService.getMostPopularFilms(count);

src/main/java/ru/yandex/practicum/filmorate/controller/ReviewController.java

@@ -0,0 +1,65 @@
+package ru.yandex.practicum.filmorate.controller;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.*;
+import ru.yandex.practicum.filmorate.dto.ReviewDto;
+import ru.yandex.practicum.filmorate.service.ReviewService;
+
+import javax.validation.Valid;
+import java.util.List;
+
+@RestController
+@RequestMapping("/reviews")
+@RequiredArgsConstructor
+public class ReviewController {
+
+    private final ReviewService reviewService;
+
+    @PostMapping
+    @ResponseStatus(HttpStatus.CREATED)
+    public ReviewDto addReview(@Valid @RequestBody ReviewDto reviewDto) {
+        return reviewService.addReview(reviewDto);
+    }
+
+    @PutMapping
+    public ReviewDto updateReview(@Valid @RequestBody ReviewDto updatedReviewDto) {
+        return reviewService.updateReview(updatedReviewDto);
+    }
+
+    @DeleteMapping("/{id}")
+    public void deleteReview(@PathVariable long id) {
+        reviewService.deleteReview(id);
+    }
+
+    @GetMapping("/{id}")
+    public ReviewDto getReviewById(@PathVariable long id) {
+        return reviewService.getReviewById(id);
+    }
+
+    @GetMapping
+    public List<ReviewDto> getReviewsByFilmId(@RequestParam(required = false) Long filmId,
+                                              @RequestParam(required = false, defaultValue = "10") int count) {
+        return reviewService.getReviewsByFilmId(filmId, count);
+    }
+
+    @PutMapping("/{id}/like/{userId}")
+    public ReviewDto addLikeToReview(@PathVariable long id, @PathVariable long userId) {
+        return reviewService.addLikeToReview(id, userId);
+    }
+
+    @PutMapping("/{id}/dislike/{userId}")
+    public ReviewDto addDislikeToReview(@PathVariable long id, @PathVariable long userId) {
+        return reviewService.addDislikeToReview(id, userId);
+    }
+
+    @DeleteMapping("/{id}/like/{userId}")
+    public ReviewDto deleteLikeFromReview(@PathVariable long id, @PathVariable long userId) {
+        return reviewService.deleteLikeFromReview(id, userId);
+    }
+
+    @DeleteMapping("/{id}/dislike/{userId}")
+    public ReviewDto deleteDislikeFromReview(@PathVariable long id, @PathVariable long userId) {
+        return reviewService.deleteDislikeFromReview(id, userId);
+    }
+}

src/main/java/ru/yandex/practicum/filmorate/dao/FilmLikeStorage.java

@@ -1,6 +1,7 @@
 package ru.yandex.practicum.filmorate.dao;
 
 import java.util.Map;
+import java.util.Set;
 
 public interface FilmLikeStorage {
     void add(long filmId, long userId);
@@ -10,4 +11,7 @@ public interface FilmLikeStorage {
     Map<Long, Long> findAll();
 
     void remove(long filmId, long userId);
+
+    Set<Long> findLikedFilmsByUser(long userId);
+
 }

src/main/java/ru/yandex/practicum/filmorate/dao/FilmStorage.java

@@ -3,7 +3,13 @@
 import ru.yandex.practicum.filmorate.model.Film;
 
 import java.util.Collection;
+import java.util.List;
+import java.util.Set;
 
 public interface FilmStorage extends Dao<Film> {
+
     Collection<Film> findMostLikedFilmsLimitBy(int count);
+
+    List<Film> findFilmsByIds(Set<Long> filmIds);
+
 }

src/main/java/ru/yandex/practicum/filmorate/dao/ReviewLikeStorage.java

@@ -0,0 +1,7 @@
+package ru.yandex.practicum.filmorate.dao;
+
+public interface ReviewLikeStorage {
+    void add(long reviewId, long userId, String type);
+
+    void delete(long reviewId, long userId, String type);
+}

src/main/java/ru/yandex/practicum/filmorate/dao/ReviewStorage.java

@@ -0,0 +1,15 @@
+package ru.yandex.practicum.filmorate.dao;
+
+import ru.yandex.practicum.filmorate.model.Review;
+
+import java.util.List;
+
+public interface ReviewStorage extends Dao<Review> {
+    List<Review> findByFilmIdLimitBy(long filmId, int count);
+
+    List<Review> findAllLimitBy(int count);
+
+    void addLikeToReview(long id);
+
+    void addDislikeToReview(long id);
+}

src/main/java/ru/yandex/practicum/filmorate/dao/impl/FilmDbStorage.java

@@ -4,6 +4,7 @@
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.dao.DataAccessException;
 import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.RowMapper;
 import org.springframework.jdbc.support.GeneratedKeyHolder;
 import org.springframework.jdbc.support.KeyHolder;
 import org.springframework.stereotype.Repository;
@@ -192,4 +193,40 @@ private Collection<Film> extractToFilmList(ResultSet rs) throws SQLException, Da
 
         return filmIdMap.values();
     }
+
+    @Override
+    public List<Film> findFilmsByIds(Set<Long> filmIds) {
+        if (filmIds.isEmpty()) {
+            return Collections.emptyList();
+        }
+
+        String placeholders = String.join(",", Collections.nCopies(filmIds.size(), "?"));
+
+        String sql = "SELECT f.ID, f.TITLE, f.DESCRIPTION, f.RELEASE_DATE, f.DURATION, f.MPA_ID, " +
+                "m.RATING_NAME, COUNT(fl.USER_ID) AS LIKES " +
+                "FROM FILM f " +
+                "LEFT JOIN MPA m ON f.MPA_ID = m.ID " +
+                "LEFT JOIN film_like fl ON f.ID = fl.FILM_ID " +
+                "WHERE f.ID IN (" + placeholders + ") " +
+                "GROUP BY f.ID, m.RATING_NAME " +
+                "ORDER BY LIKES DESC";
+
+        Object[] idsArray = filmIds.toArray(new Object[0]);
+
+        return jdbcTemplate.query(sql, idsArray, new RowMapper<Film>() {
+            @Override
+            public Film mapRow(ResultSet rs, int rowNum) throws SQLException {
+                Film film = new Film();
+                film.setId(rs.getLong("ID"));
+                film.setName(rs.getString("TITLE"));
+                film.setDescription(rs.getString("DESCRIPTION"));
+                film.setReleaseDate(rs.getDate("RELEASE_DATE").toLocalDate());
+                film.setDuration(rs.getInt("DURATION"));
+                film.setMpa(new Mpa(rs.getInt("MPA_ID"), rs.getString("RATING_NAME")));
+                film.setLikes(rs.getLong("LIKES"));
+                return film;
+            }
+        });
+    }
+
 }

src/main/java/ru/yandex/practicum/filmorate/dao/impl/FilmLikeDbStorage.java

@@ -9,8 +9,7 @@
 
 import java.sql.ResultSet;
 import java.sql.SQLException;
-import java.util.LinkedHashMap;
-import java.util.Map;
+import java.util.*;
 
 @Repository
 @RequiredArgsConstructor
@@ -49,11 +48,20 @@ public void remove(long filmId, long userId) {
         jdbcTemplate.update(sql, filmId, userId);
     }
 
+    @Override
+    public Set<Long> findLikedFilmsByUser(long userId) {
+        final String sql = "SELECT film_id FROM film_like WHERE user_id = ?";
+        List<Long> filmIds = jdbcTemplate.queryForList(sql, Long.class, userId);
+        return new HashSet<>(filmIds);
+    }
+
+
     private Map<Long, Long> mapRowToIdCount(ResultSet rs) throws SQLException {
         final Map<Long, Long> result = new LinkedHashMap<>();
         while (rs.next()) {
             result.put(rs.getLong("film_id"), rs.getLong("likes"));
         }
         return result;
     }
+
 }

src/main/java/ru/yandex/practicum/filmorate/dao/impl/ReviewDbStorage.java

@@ -0,0 +1,119 @@
+package ru.yandex.practicum.filmorate.dao.impl;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.dao.EmptyResultDataAccessException;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.support.GeneratedKeyHolder;
+import org.springframework.jdbc.support.KeyHolder;
+import org.springframework.stereotype.Repository;
+import ru.yandex.practicum.filmorate.dao.ReviewStorage;
+import ru.yandex.practicum.filmorate.exception.NotFoundException;
+import ru.yandex.practicum.filmorate.model.Review;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+
+@Repository
+@RequiredArgsConstructor
+@Slf4j
+public class ReviewDbStorage implements ReviewStorage {
+
+    private final JdbcTemplate jdbcTemplate;
+
+    @Override
+    public Review add(final Review review) {
+        final KeyHolder keyHolder = new GeneratedKeyHolder();
+        final String sql = "INSERT INTO review (review_content, is_positive, useful, user_id, film_id) VALUES (?, ?, ?, ?, ?)";
+        jdbcTemplate.update(con -> {
+            PreparedStatement stmt = con.prepareStatement(sql, new String[]{"id"});
+            stmt.setString(1, review.getContent());
+            stmt.setBoolean(2, review.isPositive());
+            stmt.setLong(3, review.getUseful());
+            stmt.setLong(4, review.getUserId());
+            stmt.setLong(5, review.getFilmId());
+            return stmt;
+        }, keyHolder);
+
+        review.setReviewId(Objects.requireNonNull(keyHolder.getKey(), "Не удалось добавить отзыв.").longValue());
+
+        return review;
+    }
+
+    @Override
+    public void remove(final long id) {
+        final String sql = "DELETE FROM review WHERE id = ?";
+        int update = jdbcTemplate.update(sql, id);
+        if (update != 1) {
+            throw new NotFoundException("Отзыв с id '" +  id + "' не найден.");
+        }
+    }
+
+    @Override
+    public void update(final Review review) {
+        final String sql = "UPDATE review SET review_content = ?, is_positive = ? WHERE id = ?";
+        final int update = jdbcTemplate.update(sql, review.getContent(), review.isPositive(), review.getReviewId());
+        if (update != 1) {
+            throw new NotFoundException("Отзыв с id '" + review.getReviewId() + "' не найден.");
+        }
+    }
+
+    @Override
+    public Collection<Review> findAll() {
+        final String sql = "SELECT id, review_content, is_positive, useful, user_id, film_id " +
+                "FROM review ORDER BY useful DESC, id";
+        return jdbcTemplate.query(sql, this::mapReview);
+    }
+
+    @Override
+    public Review findById(final long id) {
+        final String sql = "SELECT id, review_content, is_positive, useful, user_id, film_id " +
+                "FROM review WHERE id = ?";
+        try {
+            return jdbcTemplate.queryForObject(sql, this::mapReview, id);
+        } catch (EmptyResultDataAccessException e) {
+            throw new NotFoundException("Отзыв с id '" + id + "' не найден.");
+        }
+    }
+
+    @Override
+    public List<Review> findByFilmIdLimitBy(final long filmId, final int count) {
+        final String sql = "SELECT id, review_content, is_positive, useful, user_id, film_id " +
+                "FROM review WHERE film_id = ? ORDER BY useful DESC, id LIMIT ?";
+        return jdbcTemplate.query(sql, this::mapReview, filmId, count);
+    }
+
+    @Override
+    public List<Review> findAllLimitBy(final int count) {
+        final String sql = "SELECT id, review_content, is_positive, useful, user_id, film_id " +
+                "FROM review ORDER BY useful DESC, id LIMIT ?";
+        return jdbcTemplate.query(sql, this::mapReview, count);
+    }
+
+    @Override
+    public void addLikeToReview(final long id) {
+        final String sql = "UPDATE review SET useful = useful + 1 WHERE id = ?";
+        jdbcTemplate.update(sql, id);
+    }
+
+    @Override
+    public void addDislikeToReview(long id) {
+        final String sql = "UPDATE review SET useful = useful - 1 WHERE id = ?";
+        jdbcTemplate.update(sql, id);
+    }
+
+    private Review mapReview(final ResultSet rs, final int rowNum) throws SQLException {
+        return Review.builder()
+                .reviewId(rs.getLong("id"))
+                .content(rs.getString("review_content"))
+                .isPositive(rs.getBoolean("is_positive"))
+                .useful(rs.getLong("useful"))
+                .userId(rs.getLong("user_id"))
+                .filmId(rs.getLong("film_id"))
+                .build();
+    }
+}

src/main/java/ru/yandex/practicum/filmorate/dao/impl/ReviewLikeDbStorage.java

@@ -0,0 +1,27 @@
+package ru.yandex.practicum.filmorate.dao.impl;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Repository;
+import ru.yandex.practicum.filmorate.dao.ReviewLikeStorage;
+
+@Repository
+@RequiredArgsConstructor
+@Slf4j
+public class ReviewLikeDbStorage implements ReviewLikeStorage {
+
+    private final JdbcTemplate jdbcTemplate;
+
+    @Override
+    public void add(final long reviewId, final long userId, final String type) {
+        final String sql = "INSERT INTO review_like VALUES (?, ?, ?)";
+        jdbcTemplate.update(sql, reviewId, userId, type);
+    }
+
+    @Override
+    public void delete(final long reviewId, final long userId, final String type) {
+        final String sql = "DELETE FROM review_like WHERE review_id = ? AND user_id = ? AND like_type = ?";
+        jdbcTemplate.update(sql, userId, type);
+    }
+}

src/main/java/ru/yandex/practicum/filmorate/dto/ReviewDto.java

@@ -0,0 +1,26 @@
+package ru.yandex.practicum.filmorate.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotNull;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Builder
+public class ReviewDto {
+    private long reviewId;
+    @NotBlank(message = "Содержание отзыва не может быть пустым.")
+    private String content;
+    @NotNull(message = "Не указана полезность отзыва.")
+    private Boolean isPositive;
+    private long useful;
+    @NotNull(message = "Не указан идентификатор пользователя.")
+    private Long userId;
+    @NotNull(message = "Не указан идентификатор фильма.")
+    private Long filmId;
+}