Level (re)publish process rework (#935)

This rewrites a few parts in the `/lbp/publish` endpoint method, aswell
as the `AddLevel` and `UpdateLevel` methods it calls to be more similar
to the creation/updating process of other UGC (playlists for example).
For example, the endpoint method doesn't pass a `GameLevel` object to
the database methods anymore, validation is now only done in the
endpoint method while creating and modifying `GameLevel` objects is only
done in the database methods. If I understood it correctly, this also
gets rid of reflection for those methods. This PR doesn't include
anything for API endpoint and database methods.

This also gets rid of no longer nessesary attributes and methods in
`GameLevelRequest` and fixes levels to be properly marked as modded if
their contents get updated to contain something modded.

Author: jvyden

Refresh.Database/GameDatabaseContext.Levels.cs

@@ -27,19 +27,34 @@ public partial class GameDatabaseContext // Levels
         .Include(s => s.Level.Publisher)
         .Include(s => s.Level.Publisher!.Statistics);
 
-    public bool AddLevel(GameLevel level)
+    public GameLevel AddLevel(ISerializedPublishLevel createInfo, TokenGame game, GameUser publisher)
     {
-        if (level.Title is { Length: > UgcLimits.TitleLimit })
-            level.Title = level.Title[..UgcLimits.TitleLimit];
-
-        if (level.Description is { Length: > UgcLimits.DescriptionLimit })
-            level.Description = level.Description[..UgcLimits.DescriptionLimit];
-        
-        if (level.Publisher == null) throw new InvalidOperationException("Cannot create a level without a publisher");
-
         DateTimeOffset timestamp = this._time.Now;
-        level.PublishDate = timestamp;
-        level.UpdateDate = timestamp;
+
+        GameLevel level = new()
+        {
+            Title = createInfo.Title,
+            Description = createInfo.Description,
+            IconHash = createInfo.IconHash,
+            LocationX = createInfo.Location.X,
+            LocationY = createInfo.Location.Y,
+            RootResource = createInfo.RootResource,
+            IsLocked = createInfo.IsLocked,
+            IsCopyable = createInfo.IsCopyable == 1,
+            IsSubLevel = createInfo.IsSubLevel,
+            MinPlayers = createInfo.MinPlayers,
+            MaxPlayers = createInfo.MaxPlayers,
+            LevelType = GameLevelTypeExtensions.FromGameString(createInfo.LevelType),
+            RequiresMoveController = createInfo.RequiresMoveController,
+            IsAdventure = createInfo.IsAdventure,
+            EnforceMinMaxPlayers = createInfo.EnforceMinMaxPlayers,
+            SameScreenGame = createInfo.SameScreenGame,
+            BackgroundGuid = createInfo.BackgroundGuid,
+            Publisher = publisher,
+            GameVersion = game,
+            PublishDate = timestamp,
+            UpdateDate = timestamp,
+        };
 
         this.ApplyLevelMetadataFromAttributes(level);
         this.GameLevels.Add(level);
@@ -62,7 +77,7 @@ public bool AddLevel(GameLevel level)
             });
         }
 
-        return true;
+        return level;
     }
 
     public GameLevel GetStoryLevelById(int id)
@@ -156,55 +171,38 @@ public void UpdateLevelLocations(IEnumerable<ISerializedEditLevelLocation> locat
             this.AddErrorNotification("Level updates failed", $"Failed to update {failedUpdates} out of {locations.Count()} level locations.", updatingUser);
         }
     }
-    
-    public GameLevel? UpdateLevel(GameLevel newLevel, GameUser author)
-    {
-        if (newLevel.Title is { Length: > UgcLimits.TitleLimit })
-            newLevel.Title = newLevel.Title[..UgcLimits.TitleLimit];
 
-        if (newLevel.Description is { Length: > UgcLimits.DescriptionLimit })
-            newLevel.Description = newLevel.Description[..UgcLimits.DescriptionLimit];
-        
-        // Verify if this level is able to be republished
-        GameLevel? oldLevel = this.GetLevelById(newLevel.LevelId);
-        if (oldLevel == null) return null;
-            
-        Debug.Assert(oldLevel.Publisher != null);
-        if (oldLevel.Publisher.UserId != author.UserId) return null;
-        
-        // All checks passed, let's start by retaining some information from the old level
-        newLevel.Publisher = author;
-        newLevel.PublishDate = oldLevel.PublishDate;
-        newLevel.DateTeamPicked = oldLevel.DateTeamPicked;
-        newLevel.IsReUpload = oldLevel.IsReUpload;
-        newLevel.OriginalPublisher = oldLevel.OriginalPublisher;
-        
-        // If the actual contents of the level haven't changed, extract some extra information
-        if (oldLevel.RootResource == newLevel.RootResource)
-        {
-            newLevel.GameVersion = oldLevel.GameVersion;
-            newLevel.UpdateDate = oldLevel.UpdateDate;
-        }
-        // If we're changing the actual level, update other things
-        else
-        {
-            newLevel.UpdateDate = this._time.Now; // Set the last modified date
-        }
-        
-        // Now newLevel is set up to replace oldLevel.
-        // If information is lost here, then that's probably a bug.
-        // Update the level's properties in the database
-        PropertyInfo[] userProps = typeof(GameLevel).GetProperties();
-        foreach (PropertyInfo prop in userProps)
+    public GameLevel UpdateLevel(ISerializedPublishLevel updateInfo, GameLevel level, TokenGame game = TokenGame.LittleBigPlanet1)
+    {
+        level.Title = updateInfo.Title;
+        level.Description = updateInfo.Description;
+        level.IconHash = updateInfo.IconHash;
+        level.LocationX = updateInfo.Location.X;
+        level.LocationY = updateInfo.Location.Y;
+        level.IsLocked = updateInfo.IsLocked;
+        level.IsCopyable = updateInfo.IsCopyable == 1;
+        level.IsSubLevel = updateInfo.IsSubLevel;
+        level.MinPlayers = updateInfo.MinPlayers;
+        level.MaxPlayers = updateInfo.MaxPlayers;
+        level.LevelType = GameLevelTypeExtensions.FromGameString(updateInfo.LevelType);
+        level.RequiresMoveController = updateInfo.RequiresMoveController;
+        level.IsAdventure = updateInfo.IsAdventure;
+        level.EnforceMinMaxPlayers = updateInfo.EnforceMinMaxPlayers;
+        level.SameScreenGame = updateInfo.SameScreenGame;
+        level.BackgroundGuid = updateInfo.BackgroundGuid;
+
+        // If we're changing the actual contents of the level, update the game version and update date aswell
+        if (updateInfo.RootResource != level.RootResource)
         {
-            if (!prop.CanWrite || !prop.CanRead) continue;
-            prop.SetValue(oldLevel, prop.GetValue(newLevel));
+            level.UpdateDate = this._time.Now;
+            level.GameVersion = game;
+            level.RootResource = updateInfo.RootResource;
         }
 
-        this.ApplyLevelMetadataFromAttributes(newLevel);
-        this.CreateRevisionForLevel(newLevel, author);
+        this.ApplyLevelMetadataFromAttributes(level);
+        this.CreateRevisionForLevel(level, level.Publisher);
         this.SaveChanges();
-        return oldLevel;
+        return level;
     }
 
     public GameLevel? UpdateLevel(IApiEditLevelRequest body, GameLevel level, GameUser? updatingUser)

Refresh.Database/GameDatabaseContext.Notifications.cs

@@ -30,14 +30,10 @@ public void AddErrorNotification(string title, string text, GameUser user)
         this.AddNotification(title, text, user, "exclamation-circle");
     }
 
-    public void AddPublishFailNotification(string reason, GameLevel body, GameUser user)
-    {
-        this.AddPublishFailNotification(reason, body.Title, user);
-    }
-
     public void AddPublishFailNotification(string reason, string levelTitle, GameUser user)
     {
-        this.AddErrorNotification("Publish failed", $"The level '{levelTitle}' failed to publish. {reason}", user);
+        string title = string.IsNullOrWhiteSpace(levelTitle) ? "Unnamed Level" : levelTitle;
+        this.AddErrorNotification("Publish failed", $"The level '{title}' failed to publish. {reason}", user);
     }
 
     private const string LoginFail = "Log-in failure";

Refresh.Database/Query/ISerializedPublishLevel.cs

@@ -0,0 +1,23 @@
+using Refresh.Database.Models;
+
+namespace Refresh.Database.Query;
+
+public interface ISerializedPublishLevel
+{
+    string Title { get; set; }
+    string Description { get; set; }
+    string IconHash { get; set; }
+    GameLocation Location { get; set; }
+    string RootResource { get; set; }
+    int MinPlayers { get; set; }
+    int MaxPlayers { get; set; }
+    bool EnforceMinMaxPlayers { get; set; }
+    bool SameScreenGame { get; set; }
+    string LevelType { get; set; }
+    bool IsLocked { get; set; }
+    bool IsSubLevel { get; set; }
+    int IsCopyable { get; set; }
+    bool RequiresMoveController { get; set; }
+    bool IsAdventure { get; set; }
+    string? BackgroundGuid { get; set; }
+}

Refresh.Interfaces.Game/Endpoints/DataTypes/Request/GameLevelRequest.cs

@@ -1,46 +1,37 @@
 using System.Xml.Serialization;
 using Refresh.Database.Models;
 using Refresh.Database.Models.Levels;
-using Refresh.Database.Models.Users;
-using Refresh.Interfaces.Game.Types.UserData;
+using Refresh.Database.Query;
 
 namespace Refresh.Interfaces.Game.Endpoints.DataTypes.Request;
 
 [XmlRoot("slot")]
 [XmlType("slot")]
-public class GameLevelRequest
+public class GameLevelRequest : ISerializedPublishLevel
 {
-    [XmlElement("id")] public required int LevelId { get; set; }
-    
-    [XmlElement("isAdventurePlanet")] public required bool IsAdventure { get; set; }
+    // Not included if its not a republish, in that case default to 0 (invalid ID)
+    [XmlElement("id")] public int LevelId { get; set; }
 
-    [XmlElement("name")] public required string Title { get; set; }
-    [XmlElement("icon")] public required string IconHash { get; set; }
-    [XmlElement("description")] public required string Description { get; set; }
-    [XmlElement("location")] public required GameLocation Location { get; set; }
+    [XmlElement("name")] public string Title { get; set; } = "";
+    [XmlElement("icon")] public string IconHash { get; set; } = "0";
+    [XmlElement("description")] public string Description { get; set; } = "";
+    [XmlElement("location")] public GameLocation Location { get; set; } = GameLocation.Zero;
 
-    [XmlElement("game")] public required int GameVersion { get; set; }
     [XmlElement("rootLevel")] public required string RootResource { get; set; }
+    [XmlElement("isAdventurePlanet")] public bool IsAdventure { get; set; }
 
-    [XmlElement("firstPublished")] public required long PublishDate { get; set; } // unix seconds
-    [XmlElement("lastUpdated")] public required long UpdateDate { get; set; }
-    
-    [XmlElement("minPlayers")] public required int MinPlayers { get; set; }
-    [XmlElement("maxPlayers")] public required int MaxPlayers { get; set; }
-    [XmlElement("enforceMinMaxPlayers")] public required bool EnforceMinMaxPlayers { get; set; }
+    [XmlElement("minPlayers")] public int MinPlayers { get; set; } = 1;
+    [XmlElement("maxPlayers")] public int MaxPlayers { get; set; } = 4;
+    [XmlElement("enforceMinMaxPlayers")] public bool EnforceMinMaxPlayers { get; set; }
 
-    [XmlElement("sameScreenGame")] public required bool SameScreenGame { get; set; }
-
-    [XmlAttribute("type")] public string Type { get; set; } = "user";
+    [XmlElement("sameScreenGame")] public bool SameScreenGame { get; set; }
 
-    [XmlElement("npHandle")] public SerializedUserHandle Handle { get; set; } = null!;
-    
     [XmlArray("customRewards")]
     [XmlArrayItem("customReward")]
-    public required List<GameSkillReward> SkillRewards { get; set; }
+    public List<GameSkillReward> SkillRewards { get; set; } = [];
 
     [XmlElement("resource")] public List<string> XmlResources { get; set; } = new();
-    [XmlElement("leveltype")] public string? LevelType { get; set; } = "";
+    [XmlElement("leveltype")] public string LevelType { get; set; } = "";
 
     [XmlElement("initiallyLocked")] public bool IsLocked { get; set; }
     [XmlElement("isSubLevel")] public bool IsSubLevel { get; set; }
@@ -50,30 +41,4 @@ public class GameLevelRequest
     [XmlElement("backgroundGUID")] public string? BackgroundGuid { get; set; }
 
     [XmlArray("slots")] public GameLevelRequest[]? Slots { get; set; }
-    
-    public GameLevel ToGameLevel(GameUser publisher) =>
-        new()
-        {
-            LevelId = this.LevelId,
-            IsAdventure = this.IsAdventure,
-            Title = this.Title,
-            IconHash = this.IconHash,
-            Description = this.Description,
-            LocationX = this.Location.X,
-            LocationY = this.Location.Y,
-            RootResource = this.RootResource,
-            PublishDate = DateTimeOffset.FromUnixTimeMilliseconds(this.PublishDate),
-            UpdateDate = DateTimeOffset.FromUnixTimeMilliseconds(this.UpdateDate),
-            MinPlayers = this.MinPlayers,
-            MaxPlayers = this.MaxPlayers,
-            EnforceMinMaxPlayers = this.EnforceMinMaxPlayers,
-            SameScreenGame = this.SameScreenGame,
-            Publisher = publisher,
-            LevelType = GameLevelTypeExtensions.FromGameString(this.LevelType),
-            IsLocked = this.IsLocked,
-            IsSubLevel = this.IsSubLevel,
-            IsCopyable = this.IsCopyable == 1,
-            RequiresMoveController = this.RequiresMoveController,
-            BackgroundGuid = this.BackgroundGuid,
-        };
 }