My Favorites List

The My Favorites Feature

Clicking the My Favorites link in the main navigation will take you to page which contains a list of Movies that you can want to revisit later.

When a logged in user hovers their mouse over a Movie on the website, a bookmark icon appears in the top left hand corner. Clicking this icon will either add or remove the Movie from the user’s Favorites list.

When adding a Movie to the list, a POST request it sent to the /api/favorites/{id} endpoint. When this happens, the following chain of events will occur:

Likewise, when it is clicked for a Movie that has already been favorited, a DELETE request is sent to the same URL, and the Movie is removed from the list.

When adding a Movie to a User’s Favorite list, a relationship is created between the User and Movie with the type HAS_FAVORITE.

Adding a Movie to My Favorites

For the first part of this challenge, modify the add() method to open a new database session, run the Cypher statement to create te relationship, close the session and return the movie details along with an additional favorite property.

// Open a new session
try (var session = driver.session()) {

  // Do something with the session...

  // Close the session automatically in try-with-resources block
}

MATCH (u:User {userId: $userId})
MATCH (m:Movie {tmdbId: $movieId})

MERGE (u)-[r:HAS_FAVORITE]->(m)
ON CREATE SET r.createdAt = datetime()

RETURN m {
    .*,
    favorite: true
} AS movie

// Create HAS_FAVORITE relationship within a Write Transaction
var favorite = session.executeWrite(tx -> {
    String statement = """
                MATCH (u:User {userId: $userId})
                MATCH (m:Movie {tmdbId: $movieId})

                MERGE (u)-[r:HAS_FAVORITE]->(m)
                        ON CREATE SET r.createdAt = datetime()

                RETURN m {
                    .*,
                    favorite: true
                } AS movie
            """;
    var res = tx.run(statement, Values.parameters("userId", userId, "movieId", movieId));
    // return res.single().get("movie").asMap();
    return res.single().get("movie").asMap();
});

// Throw an error if the user or movie could not be found
} catch (NoSuchRecordException e) {
    throw new ValidationException(String.format("Couldn't create a favorite relationship for User %s and Movie %s", userId, movieId), Map.of("movie",movieId, "user",userId));
}

// Return movie details and `favorite` property
return favorite;

public Map<String,Object> add(String userId, String movieId) {
    // Open a new Session
    try (var session = this.driver.session()) {
        // Create HAS_FAVORITE relationship within a Write Transaction
        var favorite = session.executeWrite(tx -> {
            String statement = """
                        MATCH (u:User {userId: $userId})
                        MATCH (m:Movie {tmdbId: $movieId})

                        MERGE (u)-[r:HAS_FAVORITE]->(m)
                                ON CREATE SET r.createdAt = datetime()

                        RETURN m {
                            .*,
                            favorite: true
                        } AS movie
                    """;
            var res = tx.run(statement, Values.parameters("userId", userId, "movieId", movieId));
            // return res.single().get("movie").asMap();
            return res.single().get("movie").asMap();
        });

        // Return movie details and `favorite` property
        return favorite;
    // Throw an error if the user or movie could not be found
    } catch (NoSuchRecordException e) {
        throw new ValidationException(String.format("Couldn't create a favorite relationship for User %s and Movie %s", userId, movieId), Map.of("movie",movieId, "user",userId));
    }
}

Removing a Movie from My Favorites

The second part of this challenge is to write the code to remove a movie from the My Favorites list.

The code for deleting the HAS_FAVORITE relationship will be similar, only the Cypher statement will change.

Instead of two separate MATCH clauses, we can instead attempt to find the pattern within a single clause. If the relationship (with an variable of r) exists, we will delete it and then return the movie information with favorite set to false.

MATCH (u:User {userId: $userId})-[r:HAS_FAVORITE]->(m:Movie {tmdbId: $movieId})
DELETE r

RETURN m {
    .*,
    favorite: false
} AS movie

Use the code from the add() method above to implement the remove() function. If you get stuck, you can reveal the completed method below.

public Map<String,Object> remove(String userId, String movieId) {
    // Open a new Session
    try (var session = this.driver.session()) {
        // Removes HAS_FAVORITE relationship within a Write Transaction
        var favorite = session.executeWrite(tx -> {
            String statement = """
                      MATCH (u:User {userId: $userId})-[r:HAS_FAVORITE]->(m:Movie {tmdbId: $movieId})
                      DELETE r

                      RETURN m {
                        .*,
                        favorite: false
                      } AS movie
                    """;
            var res = tx.run(statement, Values.parameters("userId", userId, "movieId", movieId));
            return res.single().get("movie").asMap();
        });

        // Return movie details and `favorite` property
        return favorite;
    // Throw an error if the user or movie could not be found
    } catch (NoSuchRecordException e) {
        throw new ValidationException("Could not remove favorite movie for user", Map.of("movie",movieId, "user",userId));
    }
}

Listing My Favorites

Finally, the all() method in the FavoriteService currently returns a hardcoded list of Movies from the fixture popular.json.

public List<Map<String, Object>> all(String userId, Params params) {
    // Open a new session
    try (var session = this.driver.session()) {
        // Retrieve a list of movies favorited by the user
        var favorites = session.executeRead(tx -> {
            String query = String.format("""
                        MATCH (u:User {userId: $userId})-[r:HAS_FAVORITE]->(m:Movie)
                        RETURN m {
                        .*,
                            favorite: true
                        } AS movie
                        ORDER BY m.`%s` %s
                        SKIP $skip
                        LIMIT $limit
                    """, params.sort(Params.Sort.title), params.order());
            var res = tx.run(query, Values.parameters("userId", userId, "skip", params.skip(), "limit", params.limit()));
            return res.list(row -> row.get("movie").asMap());
        });
        return favorites;
    }
}

Update this method to return a paginated list of movies that the user has added to their My Favorites list.

MATCH (:User {userId: $userId})-[:HAS_FAVORITE]->(m)

RETURN m {
    .*,
    favorite: true
} AS movie

In the query the method we should also add dynamic sorting and pagination, with the string substitution for the sorting like we did in other places.

You have already written similar code a few times, so try to implement this one on your own. If you get stuck, you can view the full solution below.

public List<Map<String, Object>> all(String userId, Params params) {
    // Open a new session
    try (var session = this.driver.session()) {
        // Retrieve a list of movies favorited by the user
        var favorites = session.executeRead(tx -> {
            String query = String.format("""
                        MATCH (u:User {userId: $userId})-[r:HAS_FAVORITE]->(m:Movie)
                        RETURN m {
                        .*,
                            favorite: true
                        } AS movie
                        ORDER BY m.`%s` %s
                        SKIP $skip
                        LIMIT $limit
                    """, params.sort(Params.Sort.title), params.order());
            var res = tx.run(query, Values.parameters("userId", userId, "skip", params.skip(), "limit", params.limit()));
            return res.list(row -> row.get("movie").asMap());
        });
        return favorites;
    }
}

Testing

To test that this functionality has been correctly implemented, run the following code in a new terminal session:

mvn test -Dtest=neoflix._07_FavoritesListTest

The test file is located at src/test/java/neoflix/_07_FavoritesListTest.java.

git checkout 07-favorites-list