LBP3 Playlists

Refresh.GameServer/Database/GameDatabaseContext.Playlists.cs

@@ -1,38 +1,43 @@
 using Refresh.GameServer.Authentication;
 using Refresh.GameServer.Extensions;
+using Refresh.GameServer.Types;
 using Refresh.GameServer.Types.Levels;
 using Refresh.GameServer.Types.Playlists;
+using Refresh.GameServer.Types.Relations;
 using Refresh.GameServer.Types.UserData;
 
 namespace Refresh.GameServer.Database;
 
 public partial class GameDatabaseContext // Playlists
 {
-    public GamePlaylist CreatePlaylist(GameUser user, SerializedPlaylist createInfo, bool rootPlaylist)
+    public GamePlaylist CreatePlaylist(GameUser user, SerializedLbp1Playlist createInfo, bool rootPlaylist)
+    {
+        GamePlaylist playlist = GamePlaylist.ToGamePlaylist(createInfo, user, rootPlaylist);
+        this.CreatePlaylist(playlist);
+        return playlist;
+    }
+
+    public GamePlaylist CreatePlaylist(GameUser user, SerializedLbp3Playlist createInfo, bool rootPlaylist)
+    {
+        GamePlaylist playlist = GamePlaylist.ToGamePlaylist(createInfo, user, rootPlaylist);
+        this.CreatePlaylist(playlist);
+        return playlist;
+    }
+
+    public void CreatePlaylist(GamePlaylist createInfo)
     {
-        GamePlaylist playlist = new()
-        {
-            Publisher = user, 
-            Name = createInfo.Name,
-            Description = createInfo.Description, 
-            IconHash = createInfo.Icon, 
-            LocationX = createInfo.Location.X, 
-            LocationY = createInfo.Location.Y,
-            IsRoot = rootPlaylist,
-        };
-
         this.Write(() =>
         {
-            this.AddSequentialObject(playlist);
+            this.AddSequentialObject(createInfo);
+            createInfo.CreationDate = this._time.Now;
+            createInfo.LastUpdateDate = this._time.Now;
         });
-
-        return playlist;
     }
 
     public GamePlaylist? GetPlaylistById(int playlistId) 
         => this.GamePlaylists.FirstOrDefault(p => p.PlaylistId == playlistId);
 
-    public void UpdatePlaylist(GamePlaylist playlist, SerializedPlaylist updateInfo)
+    public void UpdatePlaylist(GamePlaylist playlist, SerializedLbp1Playlist updateInfo)
     {
         this.Write(() =>
         {
@@ -41,6 +46,17 @@ public void UpdatePlaylist(GamePlaylist playlist, SerializedPlaylist updateInfo)
             playlist.IconHash = updateInfo.Icon;
             playlist.LocationX = updateInfo.Location.X;
             playlist.LocationY = updateInfo.Location.Y;
+            playlist.LastUpdateDate = this._time.Now;
+        });
+    }
+
+    public void UpdatePlaylist(GamePlaylist playlist, SerializedLbp3Playlist updateInfo)
+    {
+        this.Write(() =>
+        {
+            if (updateInfo.Name != null) playlist.Name = updateInfo.Name;
+            if (updateInfo.Description != null) playlist.Description = updateInfo.Description;
+            playlist.LastUpdateDate = this._time.Now;
         });
     }
 
@@ -51,6 +67,7 @@ public void DeletePlaylist(GamePlaylist playlist)
             // Remove all relations relating to this playlist
             this.LevelPlaylistRelations.RemoveRange(l => l.Playlist == playlist);
             this.SubPlaylistRelations.RemoveRange(l => l.Playlist == playlist || l.SubPlaylist == playlist);
+            this.FavouritePlaylistRelations.RemoveRange(l => l.Playlist == playlist);
 
             // Remove the playlist object
             this.GamePlaylists.Remove(playlist);
@@ -101,24 +118,54 @@ public void AddLevelToPlaylist(GameLevel level, GamePlaylist parent)
             {
                 Level = level,
                 Playlist = parent,
+                // Setting TokenGame to LBP3 to get the true amount of levels in the playlist
+                Index = this.GetTotalLevelsInPlaylistCount(parent, TokenGame.LittleBigPlanet3),
             });
         });
     }
 
     public void RemoveLevelFromPlaylist(GameLevel level, GamePlaylist parent)
     {
+        LevelPlaylistRelation? relation =
+            this.LevelPlaylistRelations.FirstOrDefault(r => r.Level == level && r.Playlist == parent);
+
+        if (relation == null)
+            return;
+
+        // decrease index of every playlist level after this one by 1
+        this.DecreasePlaylistLevelIndicesAfterIndex(parent, relation.Index);
+
         this.Write(() =>
         {
-            LevelPlaylistRelation? relation =
-                this.LevelPlaylistRelations.FirstOrDefault(r => r.Level == level && r.Playlist == parent);
-
-            if (relation == null)
-                return;
-
             this.LevelPlaylistRelations.Remove(relation);
         });
     }
 
+    private void DecreasePlaylistLevelIndicesAfterIndex(GamePlaylist playlist, int index)
+    {
+        IEnumerable<LevelPlaylistRelation> relations = this.LevelPlaylistRelations
+            .Where(r => r.Playlist == playlist && r.Index >= index)
+            .AsEnumerable();
+
+
+        foreach(LevelPlaylistRelation relation in relations)
+        {
+            this.Write(() => {
+                relation.Index--;
+            });
+        }
+    }
+
+    public void SetPlaylistLevelIndex(GamePlaylist playlist, GameLevel level, int newIndex)
+    {
+        LevelPlaylistRelation relation = this.LevelPlaylistRelations
+            .First(r => r.Playlist == playlist && r.Level == level);
+
+        this.Write(() => {
+            relation.Index = newIndex;
+        });
+    }
+
     public IEnumerable<GamePlaylist> GetPlaylistsContainingPlaylist(GamePlaylist playlist)
         // TODO: with postgres this can be IQueryable
         => this.SubPlaylistRelations.Where(p => p.SubPlaylist == playlist).AsEnumerable()
@@ -132,17 +179,35 @@ public IEnumerable<GamePlaylist> GetPlaylistsByAuthorContainingPlaylist(GameUser
             .Where(p => p.Publisher.UserId == user.UserId)
             .Where(p => !p.IsRoot);
 
-    public IEnumerable<GameLevel> GetLevelsInPlaylist(GamePlaylist playlist, TokenGame game) =>
+    public IEnumerable<GameLevel> GetLevelsInPlaylist(GamePlaylist playlist, TokenGame game)
+    {
         // TODO: When we have postgres, remove the `AsEnumerable` call for performance. 
+        IEnumerable<LevelPlaylistRelation> relations = this.LevelPlaylistRelations
+            .Where(l => l.Playlist == playlist).AsEnumerable();
+
+        // Only sort by order if needed, to improve performance
+        if (game == TokenGame.LittleBigPlanet3)
+            relations = relations.OrderBy(r => r.Index);
+
+        return relations.Select(l => l.Level).FilterByGameVersion(game);
+    }
+
+    public int GetTotalLevelsInPlaylistCount(GamePlaylist playlist, TokenGame game) => 
         this.LevelPlaylistRelations.Where(l => l.Playlist == playlist).AsEnumerable()
             .Select(l => l.Level)
-            .FilterByGameVersion(game);
+            .FilterByGameVersion(game)
+            .Count();
 
     public IEnumerable<GamePlaylist> GetPlaylistsInPlaylist(GamePlaylist playlist)
         // TODO: When we have postgres, remove the `AsEnumerable` call for performance. 
         => this.SubPlaylistRelations.Where(p => p.Playlist == playlist).AsEnumerable()
             .Select(l => l.SubPlaylist);
 
+    public IEnumerable<GamePlaylist> GetPlaylistsByAuthor(GameUser author)
+        // TODO: When we have postgres, remove the `AsEnumerable` call for performance. 
+        => this.GamePlaylists.Where(p => p.Publisher == author).AsEnumerable()
+            .Where(p => !p.IsRoot);
+
     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()
@@ -153,4 +218,41 @@ 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.Playlist.PlaylistId));
+
+    public bool IsPlaylistFavouritedByUser(GamePlaylist playlist, GameUser user)
+        => this.FavouritePlaylistRelations.FirstOrDefault(r => r.Playlist == playlist && r.User == user) != null;
+
+    public IEnumerable<GamePlaylist> GetPlaylistsFavouritedByUser(GameUser user) => this.FavouritePlaylistRelations
+        .Where(r => r.User == user).AsEnumerable()
+        .Select(r => r.Playlist);
+
+    public int GetFavouriteCountForPlaylist(GamePlaylist playlist)
+        => this.FavouritePlaylistRelations
+            .Count(r => r.Playlist == playlist);
+
+    public bool FavouritePlaylist(GamePlaylist playlist, GameUser user)
+    {
+        if (this.IsPlaylistFavouritedByUser(playlist, user)) return false;
+
+        FavouritePlaylistRelation relation = new()
+        {
+            Playlist = playlist,
+            User = user, 
+        };
+        this.Write(() => this.FavouritePlaylistRelations.Add(relation));
+
+        return true;
+    }
+
+    public bool UnfavouritePlaylist(GamePlaylist playlist, GameUser user)
+    {
+        FavouritePlaylistRelation? relation = this.FavouritePlaylistRelations
+            .FirstOrDefault(r => r.Playlist == playlist && r.User == user);
+
+        if (relation == null) return false;
+
+        this.Write(() => this.FavouritePlaylistRelations.Remove(relation));
+
+        return true;
+    }
 }

Refresh.GameServer/Database/GameDatabaseContext.cs

@@ -61,6 +61,7 @@ public partial class GameDatabaseContext : RealmDatabaseContext
     private RealmDbSet<GamePlaylist> GamePlaylists => new(this._realm);
     private RealmDbSet<LevelPlaylistRelation> LevelPlaylistRelations => new(this._realm);
     private RealmDbSet<SubPlaylistRelation> SubPlaylistRelations => new(this._realm);
+    private RealmDbSet<FavouritePlaylistRelation> FavouritePlaylistRelations => new(this._realm);
     private RealmDbSet<GameUserVerifiedIpRelation> GameUserVerifiedIpRelations => new(this._realm);
 
     internal GameDatabaseContext(IDateTimeProvider time)

Refresh.GameServer/Database/GameDatabaseProvider.cs

@@ -34,7 +34,7 @@ protected GameDatabaseProvider(IDateTimeProvider time)
         this._time = time;
     }
 
-    protected override ulong SchemaVersion => 161;
+    protected override ulong SchemaVersion => 163;
 
     protected override string Filename => "refreshGameServer.realm";
 
@@ -87,6 +87,7 @@ protected GameDatabaseProvider(IDateTimeProvider time)
         typeof(GamePlaylist),
         typeof(LevelPlaylistRelation),
         typeof(SubPlaylistRelation),
+        typeof(FavouritePlaylistRelation)
     ];
 
     public override void Warmup()
@@ -686,7 +687,7 @@ protected override void Migrate(Migration migration, ulong oldVersion)
         // We weren't deleting level playlist relations when a level was deleted. Version 160 fixes this.
         if (oldVersion < 160)
             migration.NewRealm.RemoveRange(migration.NewRealm.All<LevelPlaylistRelation>().Where(r => r.Level == null));
-        
+
         // IQueryable<dynamic>? oldLevelPlaylistRelations = migration.OldRealm.DynamicApi.All("LevelPlaylistRelation");
         // IQueryable<LevelPlaylistRelation>? newLevelPlaylistRelations = migration.NewRealm.All<LevelPlaylistRelation>();
         // if (oldVersion < 155)
@@ -704,5 +705,20 @@ protected override void Migrate(Migration migration, ulong oldVersion)
         //         dynamic oldSubPlaylistRelation = oldSubPlaylistRelations.ElementAt(i);
         //         SubPlaylistRelation newSubPlaylistRelation = newSubPlaylistRelations.ElementAt(i);
         //     }
+
+        // Version 163 added indices for LevelPlaylistRelations for custom playlist level order in LBP3
+        IQueryable<dynamic>? oldLevelPlaylistRelations = migration.OldRealm.DynamicApi.All("LevelPlaylistRelation");
+        IQueryable<LevelPlaylistRelation>? newLevelPlaylistRelations = migration.NewRealm.All<LevelPlaylistRelation>();
+        if (oldVersion < 163)
+            for (int i = 0; i < newLevelPlaylistRelations.Count(); i++)
+            {
+                dynamic oldLevelPlaylistRelation = oldLevelPlaylistRelations.ElementAt(i);
+                LevelPlaylistRelation newLevelPlaylistRelation = newLevelPlaylistRelations.ElementAt(i);
+
+                if (oldVersion < 163)
+                {
+                    newLevelPlaylistRelation.Index = 0;
+                }
+            }
     }
 }

Refresh.GameServer/Endpoints/Game/Levels/LevelEndpoints.cs

@@ -141,7 +141,7 @@ public class LevelEndpoints : EndpointGroup
 
         foreach (string levelIdStr in levelIds)
         {
-            if (!int.TryParse(levelIdStr, out int levelId)) return null;
+            if (!int.TryParse(levelIdStr.StartsWith('d') ? levelIdStr[1..] : levelIdStr, out int levelId)) continue;
             GameLevel? level = database.GetLevelById(levelId);
 
             if (level == null) continue;

Refresh.GameServer/Endpoints/Game/Playlists/PlaylistEndpoints.cs → Refresh.GameServer/Endpoints/Game/Playlists/PlaylistLbp1Endpoints.cs

@@ -15,12 +15,12 @@
 
 namespace Refresh.GameServer.Endpoints.Game.Playlists;
 
-public class PlaylistEndpoints : EndpointGroup
+public class PlaylistLbp1Endpoints : EndpointGroup
 {
     // Creates a playlist, with an optional parent ID
     [GameEndpoint("createPlaylist", HttpMethods.Post, ContentType.Xml)]
     [RequireEmailVerified]
-    public Response CreatePlaylist(RequestContext context, DataContext dataContext, SerializedPlaylist body)
+    public Response CreatePlaylist(RequestContext context, DataContext dataContext, SerializedLbp1Playlist body)
     {
         GameUser user = dataContext.User!;
 
@@ -43,6 +43,8 @@ public Response CreatePlaylist(RequestContext context, DataContext dataContext,
                 return BadRequest;
         }
 
+
+
         // Create the playlist, marking it as the root playlist if the user does not have one set already
         GamePlaylist playlist = dataContext.Database.CreatePlaylist(user, body, user.RootPlaylist == null);
 
@@ -55,7 +57,7 @@ public Response CreatePlaylist(RequestContext context, DataContext dataContext,
             dataContext.Database.SetUserRootPlaylist(user, playlist);
 
         // Create the new playlist, returning the data
-        return new Response(SerializedPlaylist.FromOld(playlist, dataContext), ContentType.Xml);
+        return new Response(SerializedLbp1Playlist.FromOld(playlist, dataContext), ContentType.Xml);
     }
 
     // Gets the slots contained within a playlist
@@ -147,7 +149,7 @@ public Response CreatePlaylist(RequestContext context, DataContext dataContext,
 
     [GameEndpoint("setPlaylistMetaData/{id}", HttpMethods.Post, ContentType.Xml)]
     [RequireEmailVerified]
-    public Response UpdatePlaylistMetadata(RequestContext context, GameDatabaseContext database, GameUser user, int id, SerializedPlaylist body)
+    public Response UpdatePlaylistMetadata(RequestContext context, GameDatabaseContext database, GameUser user, int id, SerializedLbp1Playlist body)
     {
         GamePlaylist? playlist = database.GetPlaylistById(id);
         if (playlist == null)