feat: api support for playlist bookmarks

config.properties

@@ -80,7 +80,7 @@ MATRIX_SERVER:https://matrix-client.matrix.org
 #S3_BUCKET:INSERT_HERE
 
 # Hibernate properties
-hibernate.connection.url:jdbc:postgresql://postgres:5432/piped
+hibernate.connection.url:jdbc:postgresql://localhost:5432/piped
 hibernate.connection.driver_class:org.postgresql.Driver
 hibernate.dialect:org.hibernate.dialect.PostgreSQLDialect
 hibernate.connection.username:piped

docker-compose.yml

@@ -1,18 +1,11 @@
 services:
-    piped:
-        image: 1337kavin/piped:latest
-        restart: unless-stopped
-        ports:
-            - "127.0.0.1:8080:8080"
-        volumes:
-            - ./config.properties:/app/config.properties
-        depends_on:
-            - postgres
     postgres:
         image: postgres:16-alpine
         restart: unless-stopped
         volumes:
             - ./data/db:/var/lib/postgresql/data
+        ports:
+            - 5432:5432
         environment:
             - POSTGRES_DB=piped
             - POSTGRES_USER=piped

src/main/java/me/kavin/piped/server/ServerLauncher.java

@@ -11,10 +11,7 @@
 import it.unimi.dsi.fastutil.objects.ObjectArrayList;
 import me.kavin.piped.consts.Constants;
 import me.kavin.piped.server.handlers.*;
-import me.kavin.piped.server.handlers.auth.AuthPlaylistHandlers;
-import me.kavin.piped.server.handlers.auth.FeedHandlers;
-import me.kavin.piped.server.handlers.auth.StorageHandlers;
-import me.kavin.piped.server.handlers.auth.UserHandlers;
+import me.kavin.piped.server.handlers.auth.*;
 import me.kavin.piped.utils.*;
 import me.kavin.piped.utils.resp.*;
 import org.apache.commons.lang3.StringUtils;
@@ -453,6 +450,34 @@ AsyncServlet mainServlet(Executor executor) {
                     } catch (Exception e) {
                         return getErrorResponse(e, request.getPath());
                     }
+                })).map(POST, "/user/bookmarks/create", AsyncServlet.ofBlocking(executor, request -> {
+                    try {
+                        var playlistId = mapper.readTree(request.loadBody().getResult().asArray()).get("playlistId").textValue();
+                        return getJsonResponse(PlaylistBookmarkHandlers.createPlaylistBookmarkResponse(request.getHeader(AUTHORIZATION), playlistId), "private");
+                    } catch (Exception e) {
+                        return getErrorResponse(e, request.getPath());
+                    }
+                })).map(GET, "/user/bookmarks", AsyncServlet.ofBlocking(executor, request -> {
+                    try {
+                        return getJsonResponse(PlaylistBookmarkHandlers.playlistBookmarksResponse(request.getHeader(AUTHORIZATION)), "private");
+                    } catch (Exception e) {
+                        return getErrorResponse(e, request.getPath());
+                    }
+                })).map(GET, "/user/bookmarks/bookmarked", AsyncServlet.ofBlocking(executor, request -> {
+                    try {
+                        return getJsonResponse(PlaylistBookmarkHandlers.isBookmarkedResponse(request.getHeader(AUTHORIZATION),
+                                request.getQueryParameter("playlistId")), "private");
+                    } catch (Exception e) {
+                        return getErrorResponse(e, request.getPath());
+                    }
+                })).map(POST, "/user/bookmarks/delete", AsyncServlet.ofBlocking(executor, request -> {
+                    try {
+                        var json = mapper.readTree(request.loadBody().getResult().asArray());
+                        var playlistId = json.get("playlistId").textValue();
+                        return getJsonResponse(PlaylistBookmarkHandlers.deletePlaylistBookmarkResponse(request.getHeader(AUTHORIZATION), playlistId), "private");
+                    } catch (Exception e) {
+                        return getErrorResponse(e, request.getPath());
+                    }
                 })).map(GET, "/registered/badge", AsyncServlet.ofBlocking(executor, request -> {
                     try {
                         return HttpResponse.ofCode(302).withHeader(LOCATION, GenericHandlers.registeredBadgeRedirect())

src/main/java/me/kavin/piped/server/handlers/auth/PlaylistBookmarkHandlers.java

@@ -0,0 +1,122 @@
+package me.kavin.piped.server.handlers.auth;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import it.unimi.dsi.fastutil.objects.ObjectArrayList;
+import me.kavin.piped.utils.DatabaseHelper;
+import me.kavin.piped.utils.DatabaseSessionFactory;
+import me.kavin.piped.utils.ExceptionHandler;
+import me.kavin.piped.utils.obj.db.PlaylistBookmark;
+import me.kavin.piped.utils.obj.db.User;
+import me.kavin.piped.utils.resp.AcceptedResponse;
+import me.kavin.piped.utils.resp.AuthenticationFailureResponse;
+import me.kavin.piped.utils.resp.BookmarkedStatusResponse;
+import me.kavin.piped.utils.resp.InvalidRequestResponse;
+import org.apache.commons.lang3.StringUtils;
+import org.hibernate.Session;
+import org.schabi.newpipe.extractor.exceptions.ExtractionException;
+import org.schabi.newpipe.extractor.playlist.PlaylistInfo;
+
+import java.io.IOException;
+
+import static me.kavin.piped.consts.Constants.mapper;
+import static me.kavin.piped.utils.URLUtils.*;
+
+public class PlaylistBookmarkHandlers {
+    public static byte[] createPlaylistBookmarkResponse(String session, String playlistId) throws IOException, ExtractionException {
+
+        if (StringUtils.isBlank(session) || StringUtils.isBlank(playlistId))
+            ExceptionHandler.throwErrorResponse(new InvalidRequestResponse("session and name are required parameters"));
+
+        User user = DatabaseHelper.getUserFromSession(session);
+
+        if (user == null) ExceptionHandler.throwErrorResponse(new AuthenticationFailureResponse());
+
+        try (Session s = DatabaseSessionFactory.createSession()) {
+            if (DatabaseHelper.isBookmarked(s, user, playlistId)) {
+                var bookmark = DatabaseHelper.getPlaylistBookmarkFromPlaylistId(s, user, playlistId);
+                return mapper.writeValueAsBytes(createPlaylistBookmarkResponseItem(bookmark));
+            }
+
+            final PlaylistInfo info = PlaylistInfo.getInfo("https://www.youtube.com/playlist?list=" + playlistId);
+
+            var playlistBookmark = new PlaylistBookmark(playlistId, info.getName(), info.getDescription().getContent(), getLastThumbnail(info.getThumbnails()), info.getUploaderName(), substringYouTube(info.getUploaderUrl()), getLastThumbnail(info.getUploaderAvatars()), info.getStreamCount(), user);
+
+            var tr = s.beginTransaction();
+            s.persist(playlistBookmark);
+            tr.commit();
+
+            ObjectNode response = createPlaylistBookmarkResponseItem(playlistBookmark);
+
+            return mapper.writeValueAsBytes(response);
+        }
+    }
+
+    public static byte[] deletePlaylistBookmarkResponse(String session, String playlistId) throws IOException {
+
+        if (StringUtils.isBlank(session) || StringUtils.isBlank(playlistId))
+            ExceptionHandler.throwErrorResponse(new InvalidRequestResponse("session and playlistId are required parameters"));
+
+        User user = DatabaseHelper.getUserFromSession(session);
+
+        if (user == null) ExceptionHandler.throwErrorResponse(new AuthenticationFailureResponse());
+
+        try (Session s = DatabaseSessionFactory.createSession()) {
+
+            DatabaseHelper.deletePlaylistBookmark(s, user, playlistId);
+
+            return mapper.writeValueAsBytes(new AcceptedResponse());
+        }
+    }
+
+    public static byte[] playlistBookmarksResponse(String session) throws IOException {
+
+        if (StringUtils.isBlank(session))
+            ExceptionHandler.throwErrorResponse(new InvalidRequestResponse("session is a required parameter"));
+
+        User user = DatabaseHelper.getUserFromSession(session);
+
+        if (user == null) ExceptionHandler.throwErrorResponse(new AuthenticationFailureResponse());
+
+        try (Session s = DatabaseSessionFactory.createSession()) {
+
+            var responseArray = new ObjectArrayList<>();
+            var playlistBookmarks = DatabaseHelper.getPlaylistBookmarks(s, user);
+
+            for (PlaylistBookmark bookmark : playlistBookmarks) {
+                responseArray.add(createPlaylistBookmarkResponseItem(bookmark));
+            }
+
+            return mapper.writeValueAsBytes(responseArray);
+        }
+    }
+
+    public static byte[] isBookmarkedResponse(String session, String playlistId) throws IOException {
+
+        if (StringUtils.isBlank(session) || StringUtils.isBlank(playlistId))
+            ExceptionHandler.throwErrorResponse(new InvalidRequestResponse("session and playlistId are required parameters"));
+
+        User user = DatabaseHelper.getUserFromSession(session);
+
+        if (user == null) ExceptionHandler.throwErrorResponse(new AuthenticationFailureResponse());
+
+        try (Session s = DatabaseSessionFactory.createSession()) {
+            boolean isBookmarked = DatabaseHelper.isBookmarked(s, user, playlistId);
+
+            return mapper.writeValueAsBytes(new BookmarkedStatusResponse(isBookmarked));
+        }
+    }
+
+    private static ObjectNode createPlaylistBookmarkResponseItem(PlaylistBookmark bookmark) {
+        ObjectNode node = mapper.createObjectNode();
+        node.put("playlistId", String.valueOf(bookmark.getPlaylistId()));
+        node.put("name", bookmark.getName());
+        node.put("shortDescription", bookmark.getShortDescription());
+        node.put("thumbnailUrl", rewriteURL(bookmark.getThumbnailUrl()));
+        node.put("uploader", bookmark.getUploader());
+        node.put("uploaderUrl", bookmark.getUploaderUrl());
+        node.put("uploaderAvatar", rewriteURL(bookmark.getUploaderAvatar()));
+        node.put("videos", bookmark.getVideoCount());
+        return node;
+    }
+}

src/main/java/me/kavin/piped/utils/DatabaseHelper.java

@@ -6,8 +6,10 @@
 import jakarta.persistence.criteria.Root;
 import me.kavin.piped.consts.Constants;
 import me.kavin.piped.utils.obj.db.*;
+import me.kavin.piped.utils.resp.InvalidRequestResponse;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.exception.ExceptionUtils;
+import org.hibernate.Session;
 import org.hibernate.SharedSessionContract;
 import org.hibernate.StatelessSession;
 import org.schabi.newpipe.extractor.channel.ChannelInfo;
@@ -236,4 +238,47 @@ public static Channel saveChannel(String channelId) {
 
         return channel;
     }
+
+    public static List<PlaylistBookmark> getPlaylistBookmarks(SharedSessionContract s, User user) {
+        CriteriaBuilder cb = s.getCriteriaBuilder();
+        CriteriaQuery<PlaylistBookmark> cr = cb.createQuery(PlaylistBookmark.class);
+        Root<PlaylistBookmark> root = cr.from(PlaylistBookmark.class);
+        cr.select(root).where(cb.equal(root.get("owner"), user));
+
+        return s.createQuery(cr).getResultList();
+    }
+
+    public static boolean isBookmarked(SharedSessionContract s, User user, String playlistId) {
+        CriteriaBuilder cb = s.getCriteriaBuilder();
+
+        CriteriaQuery<Long> cr = cb.createQuery(Long.class);
+        Root<PlaylistBookmark> root = cr.from(PlaylistBookmark.class);
+        cr.select(cb.count(root)).where(cb.and(
+                        cb.equal(root.get("owner"), user)),
+                cb.equal(root.get("playlist_id"), playlistId)
+        );
+
+        return s.createQuery(cr).getSingleResult() > 0;
+    }
+
+    public static PlaylistBookmark getPlaylistBookmarkFromPlaylistId(SharedSessionContract s, User user, String playlistId) {
+        CriteriaBuilder cb = s.getCriteriaBuilder();
+
+        CriteriaQuery<PlaylistBookmark> cr = cb.createQuery(PlaylistBookmark.class);
+        Root<PlaylistBookmark> root = cr.from(PlaylistBookmark.class);
+        cr.select(root).where(cb.and(
+                        cb.equal(root.get("owner"), user)),
+                cb.equal(root.get("playlist_id"), playlistId)
+        );
+
+        return s.createQuery(cr).uniqueResult();
+    }
+
+    public static void deletePlaylistBookmark(Session s, User user, String playlistId) {
+        var playlistBookmark = DatabaseHelper.getPlaylistBookmarkFromPlaylistId(s, user, playlistId);
+
+        var tr = s.beginTransaction();
+        s.remove(playlistBookmark);
+        tr.commit();
+    }
 }

src/main/java/me/kavin/piped/utils/DatabaseSessionFactory.java

@@ -20,7 +20,8 @@ public class DatabaseSessionFactory {
 
             sessionFactory = configuration.addAnnotatedClass(User.class).addAnnotatedClass(Channel.class)
                     .addAnnotatedClass(Video.class).addAnnotatedClass(PubSub.class).addAnnotatedClass(Playlist.class)
-                    .addAnnotatedClass(PlaylistVideo.class).addAnnotatedClass(UnauthenticatedSubscription.class).buildSessionFactory();
+                    .addAnnotatedClass(PlaylistVideo.class).addAnnotatedClass(UnauthenticatedSubscription.class)
+                    .addAnnotatedClass(PlaylistBookmark.class).buildSessionFactory();
         } catch (Exception e) {
             throw new RuntimeException(e);
         }