LBP1 Playlists

Refresh.GameServer/Database/GameDatabaseContext.Levels.cs

@@ -51,7 +51,7 @@ public GameLevel GetStoryLevelById(int id)
         {
             Title = $"Story level #{id}",
             Publisher = null,
-            Source = GameLevelSource.Story,
+            Source = GameSlotType.Story,
             StoryId = id,
         };
 
@@ -181,7 +181,7 @@ public void DeleteLevel(GameLevel level)
     }
 
     private IQueryable<GameLevel> GetLevelsByGameVersion(TokenGame gameVersion) 
-        => this.GameLevels.Where(l => l._Source == (int)GameLevelSource.User).FilterByGameVersion(gameVersion);
+        => this.GameLevels.Where(l => l._Source == (int)GameSlotType.User).FilterByGameVersion(gameVersion);
 
     [Pure]
     public DatabaseList<GameLevel> GetLevelsByUser(GameUser user, int count, int skip, LevelFilterSettings levelFilterSettings, GameUser? accessor)
@@ -209,11 +209,11 @@ public DatabaseList<GameLevel> GetLevelsByUser(GameUser user, int count, int ski
 
     [Pure]
     public DatabaseList<GameLevel> GetUserLevelsChunk(int skip, int count)
-        => new(this.GameLevels.Where(l => l._Source == (int)GameLevelSource.User), skip, count);
+        => new(this.GameLevels.Where(l => l._Source == (int)GameSlotType.User), skip, count);
 
     [Pure]
     public IQueryable<GameLevel> GetAllUserLevels()
-        => this.GameLevels.Where(l => l._Source == (int)GameLevelSource.User);
+        => this.GameLevels.Where(l => l._Source == (int)GameSlotType.User);
 
     [Pure]
     public DatabaseList<GameLevel> GetNewestLevels(int count, int skip, GameUser? user, LevelFilterSettings levelFilterSettings) =>
@@ -245,7 +245,7 @@ public DatabaseList<GameLevel> GetMostHeartedLevels(int count, int skip, GameUse
             .OrderByDescending(x => x.Count)
             .Select(x => x.Level)
             .Where(l => l != null)
-            .Where(l => l._Source == (int)GameLevelSource.User)
+            .Where(l => l._Source == (int)GameSlotType.User)
             .FilterByLevelFilterSettings(user, levelFilterSettings)
             .FilterByGameVersion(levelFilterSettings.GameVersion);
 
@@ -262,7 +262,7 @@ public DatabaseList<GameLevel> GetLevelsByTag(int count, int skip, GameUser? use
             .AsEnumerable()
             .Select(x => x.Level)
             .Distinct()
-            .Where(l => l._Source == (int)GameLevelSource.User)
+            .Where(l => l._Source == (int)GameSlotType.User)
             .OrderByDescending(l => l.PublishDate)
             .FilterByLevelFilterSettings(user, levelFilterSettings)
             .FilterByGameVersion(levelFilterSettings.GameVersion);
@@ -282,7 +282,7 @@ public DatabaseList<GameLevel> GetMostUniquelyPlayedLevels(int count, int skip,
             .OrderByDescending(x => x.Count)
             .Select(x => x.Level)
             .Where(l => l != null)
-            .Where(l => l._Source == (int)GameLevelSource.User)
+            .Where(l => l._Source == (int)GameSlotType.User)
             .FilterByLevelFilterSettings(user, levelFilterSettings)
             .FilterByGameVersion(levelFilterSettings.GameVersion);
 
@@ -319,7 +319,7 @@ public DatabaseList<GameLevel> GetHighestRatedLevels(int count, int skip, GameUs
             .OrderByDescending(x => x.Karma) // reddit moment
             .Select(x => x.Level)
             .Where(l => l != null)
-            .Where(l => l._Source == (int)GameLevelSource.User)
+            .Where(l => l._Source == (int)GameSlotType.User)
             .FilterByLevelFilterSettings(user, levelFilterSettings)
             .FilterByGameVersion(levelFilterSettings.GameVersion);
 
@@ -336,7 +336,7 @@ public DatabaseList<GameLevel> GetTeamPickedLevels(int count, int skip, GameUser
     [Pure]
     public DatabaseList<GameLevel> GetDeveloperLevels(int count, int skip, LevelFilterSettings levelFilterSettings) =>
         new(this.GameLevels
-            .Where(l => l._Source == (int)GameLevelSource.Story)
+            .Where(l => l._Source == (int)GameSlotType.Story)
             .FilterByLevelFilterSettings(null, levelFilterSettings)
             .OrderByDescending(l => l.Title), skip, count);
 
@@ -349,7 +349,7 @@ public DatabaseList<GameLevel> GetBusiestLevels(int count, int skip, MatchServic
             .OrderBy(r => r.Sum(room => room.PlayerIds.Count));
 
         return new DatabaseList<GameLevel>(rooms.Select(r => r.Key)
-            .Where(l => l != null && l._Source == (int)GameLevelSource.User)!
+            .Where(l => l != null && l._Source == (int)GameSlotType.User)!
             .FilterByLevelFilterSettings(user, levelFilterSettings)
             .FilterByGameVersion(levelFilterSettings.GameVersion), skip, count);
     }
@@ -402,13 +402,13 @@ public DatabaseList<GameLevel> SearchForLevels(int count, int skip, GameUser? us
     }
 
     [Pure]
-    public int GetTotalLevelCount(TokenGame game) => this.GameLevels.FilterByGameVersion(game).Count(l => l._Source == (int)GameLevelSource.User);
+    public int GetTotalLevelCount(TokenGame game) => this.GameLevels.FilterByGameVersion(game).Count(l => l._Source == (int)GameSlotType.User);
 
     [Pure]
-    public int GetTotalLevelCount() => this.GameLevels.Count(l => l._Source == (int)GameLevelSource.User);
+    public int GetTotalLevelCount() => this.GameLevels.Count(l => l._Source == (int)GameSlotType.User);
 
     [Pure]
-    public int GetModdedLevelCount() => this.GameLevels.Count(l => l._Source == (int)GameLevelSource.User && l.IsModded);
+    public int GetModdedLevelCount() => this.GameLevels.Count(l => l._Source == (int)GameSlotType.User && l.IsModded);
 
     public int GetTotalLevelsPublishedByUser(GameUser user)
         => this.GameLevels

Refresh.GameServer/Database/GameDatabaseContext.Playlists.cs

@@ -0,0 +1,154 @@
+using Refresh.GameServer.Authentication;
+using Refresh.GameServer.Extensions;
+using Refresh.GameServer.Types.Levels;
+using Refresh.GameServer.Types.Playlists;
+using Refresh.GameServer.Types.UserData;
+
+namespace Refresh.GameServer.Database;
+
+public partial class GameDatabaseContext // Playlists
+{
+    public GamePlaylist CreatePlaylist(GameUser user, SerializedPlaylist createInfo, bool rootPlaylist)
+    {
+        GamePlaylist playlist = new()
+        {
+            Creator = user, 
+            Name = createInfo.Name,
+            Description = createInfo.Description, 
+            Icon = createInfo.Icon, 
+            LocationX = createInfo.Location.X, 
+            LocationY = createInfo.Location.Y,
+            RootPlaylist = rootPlaylist,
+        };
+
+        this.Write(() =>
+        {
+            this.AddSequentialObject(playlist);
+        });
+
+        return playlist;
+    }
+
+    public GamePlaylist? GetPlaylistById(int playlistId) 
+        => this.GamePlaylists.FirstOrDefault(p => p.PlaylistId == playlistId);
+
+    public void UpdatePlaylist(GamePlaylist playlist, SerializedPlaylist updateInfo)
+    {
+        this.Write(() =>
+        {
+            playlist.Name = updateInfo.Name;
+            playlist.Description = updateInfo.Description;
+            playlist.Icon = updateInfo.Icon;
+            playlist.LocationX = updateInfo.Location.X;
+            playlist.LocationY = updateInfo.Location.Y;
+        });
+    }
+
+    public void DeletePlaylist(GamePlaylist playlist)
+    {
+        this.Write(() =>
+        {
+            // Remove all relations relating to this playlist
+            this.LevelPlaylistRelations.RemoveRange(l => l.PlaylistId == playlist.PlaylistId);
+            this.SubPlaylistRelations.RemoveRange(l => l.PlaylistId == playlist.PlaylistId || l.SubPlaylist == playlist);
+
+            // Remove the playlist object
+            this.GamePlaylists.Remove(playlist);
+        });
+    }
+
+    public void AddPlaylistToPlaylist(GamePlaylist child, GamePlaylist parent)
+    {
+        this.Write(() =>
+        {
+            // Make sure to not create a duplicate object
+            if (this.SubPlaylistRelations.Any(p => p.SubPlaylist == child && p.PlaylistId == parent.PlaylistId))
+                return;
+
+            // Add the relation
+            this.SubPlaylistRelations.Add(new SubPlaylistRelation
+            {
+                PlaylistId = parent.PlaylistId,
+                SubPlaylist = child,
+            });
+        });
+    }
+
+    public void RemovePlaylistFromPlaylist(GamePlaylist child, GamePlaylist parent)
+    {
+        this.Write(() =>
+        {
+            SubPlaylistRelation? relation =
+                this.SubPlaylistRelations.FirstOrDefault(r => r.SubPlaylist == child && r.PlaylistId == parent.PlaylistId);
+
+            if (relation == null)
+                return;
+
+            this.SubPlaylistRelations.Remove(relation);
+        });
+    }
+
+    public void AddLevelToPlaylist(GameLevel level, GamePlaylist parent)
+    {
+        this.Write(() =>
+        {
+            // Make sure to not create a duplicate object
+            if (this.LevelPlaylistRelations.Any(p => p.Level == level && p.PlaylistId == parent.PlaylistId))
+                return;
+
+            // Add the relation
+            this.LevelPlaylistRelations.Add(new LevelPlaylistRelation
+            {
+                Level = level,
+                PlaylistId = parent.PlaylistId,
+            });
+        });
+    }
+
+    public void RemoveLevelFromPlaylist(GameLevel level, GamePlaylist parent)
+    {
+        this.Write(() =>
+        {
+            LevelPlaylistRelation? relation =
+                this.LevelPlaylistRelations.FirstOrDefault(r => r.Level == level && r.PlaylistId == parent.PlaylistId);
+
+            if (relation == null)
+                return;
+
+            this.LevelPlaylistRelations.Remove(relation);
+        });
+    }
+
+    public IEnumerable<GamePlaylist> GetPlaylistsContainingPlaylist(GamePlaylist playlist)
+        // TODO: with postgres this can be IQueryable
+        => this.SubPlaylistRelations.Where(p => p.SubPlaylist == playlist).AsEnumerable()
+            .Select(r => this.GamePlaylists.First(p => p.PlaylistId == r.PlaylistId))
+            .Where(p => !p.RootPlaylist);
+
+    public IEnumerable<GamePlaylist> GetPlaylistsByAuthorContainingPlaylist(GameUser user, GamePlaylist playlist)
+        // TODO: with postgres this can be IQueryable
+        => this.SubPlaylistRelations.Where(p => p.SubPlaylist == playlist).AsEnumerable()
+            .Select(r => this.GamePlaylists.First(p => p.PlaylistId == r.PlaylistId))
+            .Where(p => p.Creator.UserId == user.UserId)
+            .Where(p => !p.RootPlaylist);
+
+    public IEnumerable<GameLevel> GetLevelsInPlaylist(GamePlaylist playlist, TokenGame game) =>
+        // TODO: When we have postgres, remove the `AsEnumerable` call for performance. 
+        this.LevelPlaylistRelations.Where(l => l.PlaylistId == playlist.PlaylistId).AsEnumerable()
+            .Select(l => l.Level).FilterByGameVersion(game);
+
+    public IEnumerable<GamePlaylist> GetPlaylistsInPlaylist(GamePlaylist playlist)
+        // TODO: When we have postgres, remove the `AsEnumerable` call for performance. 
+        => this.SubPlaylistRelations.Where(p => p.PlaylistId == playlist.PlaylistId).AsEnumerable().Select(l => l.SubPlaylist);
+
+    public IEnumerable<GamePlaylist> GetPlaylistsByAuthorContainingLevel(GameUser author, GameLevel level)
+        // TODO: When we have postgres, remove the `AsEnumerable` call for performance. 
+        => this.LevelPlaylistRelations.Where(p => p.Level == level).AsEnumerable()
+            .Select(r => this.GamePlaylists.First(p => p.PlaylistId == r.PlaylistId))
+            .Where(p => p.Creator.UserId == author.UserId);
+
+    public IEnumerable<GamePlaylist> GetPlaylistsContainingLevel(GameLevel level)
+        // TODO: When we have postgres, remove the `AsEnumerable` call for performance. 
+        => this.LevelPlaylistRelations.Where(p => p.Level == level).AsEnumerable()
+            .Select(r => this.GamePlaylists.First(p => p.PlaylistId == r.PlaylistId));
+}

Refresh.GameServer/Database/GameDatabaseContext.Users.cs

@@ -3,10 +3,9 @@
 using Refresh.Common.Constants;
 using Refresh.GameServer.Authentication;
 using Refresh.GameServer.Endpoints.ApiV3.DataTypes.Request;
-using Refresh.GameServer.Types;
 using Refresh.GameServer.Types.Levels;
 using Refresh.GameServer.Types.Photos;
-using Refresh.GameServer.Types.Relations;
+using Refresh.GameServer.Types.Playlists;
 using Refresh.GameServer.Types.Roles;
 using Refresh.GameServer.Types.UserData;
 
@@ -448,4 +447,12 @@ public void MarkAllReuploads(GameUser user)
             }
         });
     }
+
+    public void SetUserRootPlaylist(GameUser user, GamePlaylist playlist)
+    {
+        this.Write(() =>
+        {
+            user.RootPlaylist = playlist;
+        });
+    }
 }

Refresh.GameServer/Database/GameDatabaseContext.cs

@@ -13,6 +13,7 @@
 using Refresh.GameServer.Types.Levels;
 using Refresh.GameServer.Types.Notifications;
 using Refresh.GameServer.Types.Photos;
+using Refresh.GameServer.Types.Playlists;
 using Refresh.GameServer.Types.Relations;
 using Refresh.GameServer.Types.Reviews;
 using Refresh.GameServer.Types.UserData;
@@ -57,6 +58,9 @@ public partial class GameDatabaseContext : RealmDatabaseContext
     private RealmDbSet<DisallowedUser> DisallowedUsers => new(this._realm);
     private RealmDbSet<RateReviewRelation> RateReviewRelations => new(this._realm);
     private RealmDbSet<TagLevelRelation> TagLevelRelations => new(this._realm);
+    private RealmDbSet<GamePlaylist> GamePlaylists => new(this._realm);
+    private RealmDbSet<LevelPlaylistRelation> LevelPlaylistRelations => new(this._realm);
+    private RealmDbSet<SubPlaylistRelation> SubPlaylistRelations => new(this._realm);
 
     internal GameDatabaseContext(IDateTimeProvider time)
     {