Radicade Public Code

Server/Rooms/RoomUtils.cs

@@ -0,0 +1,574 @@
+using Microsoft.EntityFrameworkCore;
+using RadicadeServer.DB;
+using RadicadeServer.Extensions;
+using RadicadeServer.RecNet;
+using RadicadeServer.RecNet.Accounts;
+using RadicadeServer.RecNet.Enums;
+using RadicadeServer.RecNet.Enums.Messages;
+using RadicadeServer.RecNet.Enums.Rooms;
+using RadicadeServer.RecNet.Messages;
+using RadicadeServer.RecNet.Rooms;
+
+namespace RadicadeServer.Utils
+{
+	public static class RoomUtils
+	{
+		public static IDbContextFactory<RecDBContext> DbFactory = null!;
+
+		public static async Task<bool> VerifyRole(long playerId, long roomId, RoleType roleType)
+		{
+			var role = await GetRoleForPlayer(playerId, roomId);
+			if (role == null) return false;
+
+			return role.Role >= roleType;
+		}
+
+		public static async Task<bool> CanSeeRoom(RoomData room, long? accountId)
+		{
+			if (room.Accessibility != Accessibility.Private) return true;
+			if (accountId == null) return false;
+			if (room.CreatorAccountId == accountId.Value) return true;
+			if (await VerifyRole(accountId.Value, room.RoomId, RoleType.CoOwner)) return true;
+
+			if (DbFactory != null)
+			{
+				await using var db = await DbFactory.CreateDbContextAsync();
+				if (await (
+					from presence in db.Presences.AsNoTracking()
+					join instance in db.RoomInstances.AsNoTracking()
+						on presence.roomInstance equals instance.roomInstanceId
+					where presence.playerId == accountId.Value && presence.isOnline &&
+						instance.roomId == room.RoomId
+					select presence.playerId).AnyAsync()) return true;
+			}
+
+			return await HasLiveGameInvite(room.RoomId, accountId.Value);
+		}
+
+		public static async Task<bool> HasLiveGameInvite(long roomId, long accountId)
+		{
+			if (DbFactory == null) return false;
+
+			await using var db = await DbFactory.CreateDbContextAsync();
+
+			long? inviter = await db.Messages.AsNoTracking()
+				.Where(message =>
+					message.ToPlayerId == accountId &&
+					(message.Type == MessageType.GameInvite || message.Type == MessageType.GameInviteV2) &&
+					message.RoomId == roomId)
+				.OrderByDescending(message => message.Id)
+				.Select(message => (long?)message.FromPlayerId)
+				.FirstOrDefaultAsync();
+			if (inviter == null) return false;
+
+			return await (
+				from presence in db.Presences.AsNoTracking()
+				join instance in db.RoomInstances.AsNoTracking()
+					on presence.roomInstance equals instance.roomInstanceId
+				where presence.playerId == inviter.Value &&
+					presence.isOnline &&
+					instance.roomId == roomId
+				select presence.playerId).AnyAsync();
+		}
+
+		public static async Task<List<RoomData>> VisibleRooms(IEnumerable<RoomData> rooms, long? accountId)
+		{
+			var visible = new List<RoomData>();
+			foreach (var room in rooms)
+			{
+				if (await CanSeeRoom(room, accountId)) visible.Add(room);
+			}
+			return visible;
+		}
+
+		public const string PrivateRoomName = "PRIVATE ROOM";
+
+		public static async Task<bool> IsHiddenFrom(RoomData room, long? accountId)
+			=> !room.IsDorm && !await CanSeeRoom(room, accountId);
+
+		public static FullRoom MaskHiddenRoom(RoomData room)
+		{
+			return new FullRoom
+			{
+				RoomId = room.RoomId,
+				Name = PrivateRoomName,
+				Description = string.Empty,
+				ImageName = DBConfig.DefaultRoomImage,
+				IsDorm = false,
+				State = room.State,
+				Accessibility = Accessibility.Private,
+				CreatedAt = room.CreatedAt,
+				CreatorAccountId = room.CreatorAccountId,
+				MaxPlayers = room.MaxPlayers,
+				MaxPlayerCalculationMode = room.MaxPlayerCalculationMode,
+				CloningAllowed = false,
+				DisableRoomComments = true,
+				CustomWarning = string.Empty,
+				SubRooms = new List<SubRoom>(),
+				Roles = new List<RoomRole>(),
+				LoadScreens = new List<RoomLoadScreen>(),
+				PromoImages = new List<string>(),
+				PromoExternalContent = new List<ExternalContent>(),
+				DataBlob = string.Empty,
+				Tags = new List<ItemTag>(),
+				Stats = new RoomStats { RoomId = room.RoomId },
+				Version = 1
+			};
+		}
+
+		public static async Task<RoomInstance?> ForViewerAsync(RoomInstance? instance, long? viewerId)
+		{
+			if (instance == null) return null;
+
+			await using var db = await DbFactory.CreateDbContextAsync();
+			var room = await db.Rooms.AsNoTracking().FirstOrDefaultAsync(x => x.RoomId == instance.roomId);
+			if (room == null || !await IsHiddenFrom(room, viewerId)) return instance;
+
+			var masked = instance.Copy();
+			masked.name = PrivateRoomName;
+			return masked;
+		}
+		public static async Task<List<RoomRole>> GetRoles(long roomId)
+		{
+			await using var db = await DbFactory.CreateDbContextAsync();
+
+			var room = await db.Rooms.AsNoTracking().FirstOrDefaultAsync(x => x.RoomId == roomId);
+			if (room == null) return [];
+
+			var roomRole = await db.RoomRoles.AsNoTracking().Where(x => x.RoomId == roomId).ToListAsync();
+
+			var creatorRow = roomRole.FirstOrDefault(x => x.AccountId == room.CreatorAccountId);
+			if (creatorRow == null)
+				roomRole.Add(new RoomRole { AccountId = room.CreatorAccountId, InvitedRole = RoleType.None, Role = RoleType.Creator, RoomId = roomId });
+			else if (creatorRow.Role < RoleType.Creator)
+				creatorRow.Role = RoleType.Creator;
+
+			if (room.IsRRO)
+			{
+				var rroOwners = (await db.ServerConfig.AsNoTracking().FirstOrDefaultAsync(x => x.Key == "HighRanks"))?.Value;
+
+				foreach (var dev in (rroOwners ?? string.Empty).Split(',', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries))
+				{
+					if (!long.TryParse(dev, out long userId)) continue;
+
+					foreach (var role in new[] { RoleType.Creator, RoleType.Moderator })
+					{
+						if (roomRole.Any(x => x.AccountId == userId && x.Role == role)) continue;
+
+						roomRole.Add(new RoomRole { AccountId = userId, InvitedRole = RoleType.None, Role = role, RoomId = roomId });
+					}
+				}
+			}
+
+			return roomRole;
+		}
+		public static async Task<RoomRole?> GetRoleForPlayer(long playerId, long roomId)
+		{
+			var roomRoles = await GetRoles(roomId);
+
+			return roomRoles
+				.Where(x => x.AccountId == playerId)
+				.OrderByDescending(x => x.Role)
+				.FirstOrDefault();
+		}
+
+		public static SubRoomDataSave BuildCurrentSave(SubRoom subRoom)
+		{
+			return new SubRoomDataSave
+			{
+				SubRoomDataSaveId = 1,
+				SubRoomId = subRoom.SubRoomId,
+				DataBlob = subRoom.DataBlob,
+				SavedByAccountId = subRoom.SavedByAccountId,
+				CreatedAt = subRoom.CreatedAt,
+				UnityAssetId = string.IsNullOrEmpty(subRoom.UnityAssetId) ? null : subRoom.UnityAssetId,
+				PersistenceVersion = 1,
+				OMVersion = 1,
+				UgcSubVersion = 1,
+				SavedOnPlatform = 0,
+				SavedOnDeviceClass = 0,
+				Description = string.Empty,
+				ModerationState = 0
+			};
+		}
+
+		public static object BuildSaveResponse(SubRoom subRoom, string? dataBlobHash)
+		{
+			return new
+			{
+				subRoomDataSaveId = 1L,
+				subRoomId = subRoom.SubRoomId,
+				unityAssetId = string.IsNullOrEmpty(subRoom.UnityAssetId) ? null : subRoom.UnityAssetId,
+				unityAsset = (string?)null,
+				unityAssetHash = (string?)null,
+				dataBlob = subRoom.DataBlob ?? string.Empty,
+				dataBlobHash,
+				savedByAccountId = (long?)subRoom.SavedByAccountId,
+				savedOnPlatform = 0,
+				savedOnDeviceClass = 0,
+				description = string.Empty,
+				createdAt = subRoom.CreatedAt
+			};
+		}
+
+		public static async Task<List<SubRoomDataSave>> GetSaveHistory(RecDBContext ctx, long roomId, long subRoomId)
+		{
+			var subRoom = await ctx.SubRooms.AsNoTracking()
+				.FirstOrDefaultAsync(x => x.RoomId == roomId && x.SubRoomId == subRoomId);
+
+			if (subRoom == null) return new List<SubRoomDataSave>();
+
+			var saves = new List<SubRoomDataSave>();
+
+			if (!string.IsNullOrEmpty(subRoom.DataBlob)) saves.Add(BuildCurrentSave(subRoom));
+
+			var history = await ctx.SubRoomHistory.AsNoTracking()
+				.Where(x => x.RoomId == roomId && x.SubRoomId == subRoomId && x.DataBlob != "")
+				.OrderByDescending(x => x.CreatedAt)
+				.ThenByDescending(x => x.HistoryId)
+				.ToListAsync();
+
+			saves.AddRange(history.Select(BuildRestorableSave));
+
+			return saves;
+		}
+
+		public static SubRoomDataSave BuildRestorableSave(RestorableSubRoom row)
+		{
+			return new SubRoomDataSave
+			{
+				SubRoomDataSaveId = row.HistoryId + 1,
+				SubRoomId = row.SubRoomId,
+				DataBlob = row.DataBlob,
+				SavedByAccountId = row.SavedByAccountId,
+				CreatedAt = row.CreatedAt,
+				PersistenceVersion = 1,
+				OMVersion = 1,
+				UgcSubVersion = 1,
+				SavedOnPlatform = 0,
+				SavedOnDeviceClass = 0,
+				Description = string.Empty,
+				ModerationState = 0
+			};
+		}
+
+		public static FullRoom ConvertToFull(this RoomData room, List<SubRoom> subRooms, RoomStats stats, List<RoomRole> roles)
+		{
+			FullRoom fullRoom = new FullRoom
+			{
+				Name = room.Name,
+				RoomId = room.RoomId,
+				Description = room.Description ?? string.Empty,
+				ImageName = room.ImageName,
+				IsRRO = room.IsRRO,
+				IsDeveloperOwned = room.IsDeveloperOwned,
+				IsDorm = room.IsDorm,
+				State = room.State,
+				Accessibility = room.Accessibility,
+				CreatedAt = room.CreatedAt,
+				CreatorAccountId = room.CreatorAccountId,
+				SupportsJuniors = room.SupportsJuniors,
+				SupportsLevelVoting = room.SupportsLevelVoting,
+				SupportsMobile = room.SupportsMobile,
+				SupportsQuest2 = room.SupportsQuest2,
+				SupportsScreens = room.SupportsScreens,
+				SupportsTeleportVR = room.SupportsTeleportVR,
+				SupportsVRLow = room.SupportsVRLow,
+				SupportsWalkVR = room.SupportsWalkVR,
+				EncryptVoiceChat = room.EncryptVoiceChat,
+				MaxPlayerCalculationMode = room.MaxPlayerCalculationMode,
+				MaxPlayers = room.MaxPlayers,
+				SubRooms = subRooms,
+				Stats = stats,
+				CloningAllowed = room.CloningAllowed,
+				CustomWarning = room.CustomWarning ?? string.Empty,
+				Roles = roles,
+				DataBlob = null,
+				Tags = StringTools.ReadTags(room.Tags),
+				LoadScreens = room.loadScreen.FromJson<List<RoomLoadScreen>>() ?? new(),
+				WarningMask = room.WarningMask,
+				Version = room.Version,
+				DisableRoomComments = room.DisableRoomComments,
+				DisableMicAutoMute = room.DisableMicAutoMute,
+				MinLevel = room.MinLevel
+			};
+
+			foreach (var subRoom in subRooms)
+			{
+				subRoom.CurrentSave = string.IsNullOrEmpty(subRoom.DataBlob) ? null : BuildCurrentSave(subRoom);
+
+				subRoom.CreatorAccountId = subRoom.SavedByAccountId != 0 ? subRoom.SavedByAccountId : null;
+			}
+
+			return fullRoom;
+		}
+
+		public static async Task<List<FullRoom>> BulkConvertRoomData(List<RoomData> data)
+		{
+			var fullRooms = new List<FullRoom>();
+			foreach (var d in data)
+			{
+				var found = await GetRoom(d.RoomId);
+				if (found != null)
+					fullRooms.Add(found);
+			}
+			return fullRooms;
+		}
+		public static async Task<List<RoomDetail>> BulkConvertRoomDataToRoomDetail(List<RoomData> data)
+		{
+			var rooms = new List<RoomDetail>();
+			foreach (var d in data)
+			{
+				var found = await GetRoom(d.RoomId);
+				if (found != null)
+					rooms.Add(found);
+			}
+			return rooms;
+		}
+
+		public static async Task<FullRoom?> GetRoom(string Name)
+		{
+			await using var ctx = await DbFactory.CreateDbContextAsync();
+
+			var room = await ctx.Rooms.AsNoTracking().FirstOrDefaultAsync((x) => x.Name == Name);
+			if (room == null && !string.IsNullOrWhiteSpace(Name) && Name.StartsWith("@", StringComparison.Ordinal) && Name.EndsWith("'s Dorm", StringComparison.OrdinalIgnoreCase))
+			{
+				var username = Name.Substring(1, Name.Length - 8);
+				var owner = await ctx.Profiles.AsNoTracking().FirstOrDefaultAsync(x => x.username == username || x.displayName == username);
+				if (owner != null)
+				{
+					room = await ctx.Rooms.AsNoTracking().FirstOrDefaultAsync(x => x.IsDorm && x.CreatorAccountId == owner.accountId);
+				}
+			}
+			if (room == null) return null;
+
+			return await GetRoom(room.RoomId);
+		}
+		public static async Task<FullRoom?> GetRoom(long Id)
+		{
+			await using var ctx = await DbFactory.CreateDbContextAsync();
+
+			var room = await ctx.Rooms.AsNoTracking().FirstOrDefaultAsync((x) => x.RoomId == Id);
+			if (room == null) return null;
+
+			var cheers = await ctx.RoomInteractions.AsNoTracking().CountAsync(x => x.RoomId == Id && x.Cheered);
+			var favourites = await ctx.RoomInteractions.AsNoTracking().CountAsync(x => x.RoomId == Id && x.Favorited);
+			var visitorCount = await ctx.RoomInteractions.AsNoTracking().CountAsync(x => x.RoomId == Id && x.Visited);
+			var visitCount = await ctx.RoomInteractions.AsNoTracking()
+				.Where(x => x.RoomId == Id && x.Visited)
+				.SumAsync(x => (int?)x.VisitCount) ?? 0;
+
+			var roomStats = new RoomStats { CheerCount = cheers, FavoriteCount = favourites, RoomId = Id, VisitCount = visitCount, VisitorCount = visitorCount };
+
+			var roomRoles = await GetRoles(Id);
+
+			var subRooms = await ctx.SubRooms.AsNoTracking().Where((x) => x.RoomId == Id).ToListAsync();
+
+			var missingBlobs = subRooms
+				.Where(x => !string.IsNullOrEmpty(x.DataBlob) && !File.Exists(Path.Join(DBConfig.CDNStorage, x.DataBlob)))
+				.ToList();
+
+			if (missingBlobs.Count > 0)
+			{
+				var missingIds = missingBlobs.Select(x => x.SubRoomId).ToList();
+
+				var candidates = await ctx.SubRoomHistory.AsNoTracking()
+					.Where(x => missingIds.Contains(x.SubRoomId) && x.DataBlob != "")
+					.OrderByDescending(x => x.CreatedAt)
+					.ToListAsync();
+
+				foreach (var subRoom in missingBlobs)
+				{
+					var recovered = candidates
+						.Where(x => x.SubRoomId == subRoom.SubRoomId)
+						.Select(x => x.DataBlob)
+						.FirstOrDefault(blob => !string.IsNullOrEmpty(blob) && File.Exists(Path.Join(DBConfig.CDNStorage, blob)));
+
+					subRoom.DataBlob = recovered ?? "";
+					ctx.SubRooms.Attach(subRoom);
+					ctx.Entry(subRoom).Property(x => x.DataBlob).IsModified = true;
+				}
+
+				await ctx.SaveChangesAsync();
+			}
+
+			return room.ConvertToFull(subRooms, roomStats, roomRoles);
+		}
+
+		public static async Task<RoomStats?> GetRoomStats(long roomId, long? playerId)
+		{
+			await using var ctx = await DbFactory.CreateDbContextAsync();
+
+			var cheers = await ctx.RoomInteractions.AsNoTracking().CountAsync(x => x.RoomId == roomId && x.Cheered);
+			var favourites = await ctx.RoomInteractions.AsNoTracking().CountAsync(x => x.RoomId == roomId && x.Favorited);
+
+			var visitorCount = await ctx.RoomInteractions.AsNoTracking().CountAsync(x => x.RoomId == roomId && x.Visited);
+
+			var visited = 0;
+			if (playerId != null)
+			{
+				var interaction = await ctx.RoomInteractions.AsNoTracking()
+					.FirstOrDefaultAsync(x => x.RoomId == roomId && x.PlayerId == playerId);
+
+				if (interaction != null)
+					visited = interaction.VisitCount;
+			}
+
+			return new RoomStats() { CheerCount = cheers, FavoriteCount = favourites, RoomId = roomId, VisitCount = visited, VisitorCount = visitorCount };
+		}
+
+
+		public static async Task<FullRoom?> CloneRoom(long originalRoomId, long newCreator, string newName)
+		{
+			await using var ctx = await DbFactory.CreateDbContextAsync();
+
+			FullRoom? room = await GetRoom(originalRoomId);
+			if (room == null)
+				return null;
+
+
+
+			var tags = room.Tags;
+			var rro = tags.Find(x => x.Tag.StartsWith("rro") && x.Type >= TagType.Auto);
+			if (rro != null)
+				tags.Remove(rro);
+
+			RoomData roomData = new RoomData
+			{
+				State = RoomState.Active,
+				SupportsJuniors = room.SupportsJuniors,
+				SupportsLevelVoting = room.SupportsLevelVoting,
+				SupportsMobile = room.SupportsMobile,
+				SupportsQuest2 = room.SupportsQuest2,
+				SupportsScreens = room.SupportsScreens,
+				SupportsTeleportVR = room.SupportsTeleportVR,
+				SupportsVRLow = room.SupportsVRLow,
+				SupportsWalkVR = room.SupportsWalkVR,
+				Accessibility = Accessibility.Private,
+				CloningAllowed = false,
+				CreatedAt = DateTime.Now,
+				CreatorAccountId = newCreator,
+				CustomWarning = room.CustomWarning,
+				Description = room.Description,
+				DisableMicAutoMute = room.DisableMicAutoMute,
+				DisableRoomComments = room.DisableRoomComments,
+				EncryptVoiceChat = room.EncryptVoiceChat,
+				ImageName = room.ImageName,
+				IsDorm = room.IsDorm,
+				IsRRO = false,
+
+				IsDeveloperOwned = !room.IsDorm && await ctx.IsDeveloper(newCreator),
+				MaxPlayerCalculationMode = room.MaxPlayerCalculationMode,
+				MaxPlayers = room.MaxPlayers,
+				MinLevel = room.MinLevel,
+				Name = newName,
+				Tags = StringTools.CreateTagString(tags),
+				WarningMask = room.WarningMask,
+			};
+
+			await ctx.AddAsync(roomData);
+			await ctx.SaveChangesAsync();
+
+
+			if (room.SubRooms == null || room.SubRooms.Count == 0)
+			{
+				ctx.Remove(roomData);
+				await ctx.SaveChangesAsync();
+				return null;
+			}
+
+			foreach (SubRoom subRoom in room.SubRooms)
+			{
+				if (subRoom == null) continue;
+				await ctx.SubRooms.AddAsync(new SubRoom
+				{
+					Accessibility = subRoom.Accessibility,
+					DataBlob = subRoom.DataBlob,
+					UnityAssetId = subRoom.UnityAssetId,
+					IsSandbox = subRoom.IsSandbox,
+					UnitySceneId = subRoom.UnitySceneId,
+					MaxPlayers = subRoom.MaxPlayers,
+					Name = subRoom.Name,
+					RoomId = roomData.RoomId
+				});
+			}
+
+			await ctx.SaveChangesAsync();
+
+
+			await ctx.RoomStats.AddAsync(new RoomStats
+			{
+				RoomId = roomData.RoomId,
+				FavoriteCount = 0,
+				CheerCount = 0,
+				VisitCount = 0,
+				VisitorCount = 0,
+			});
+
+
+			await ctx.RoomRoles.AddAsync(new RoomRole
+			{
+				RoomId = roomData.RoomId,
+				Role = RoleType.Creator,
+				InvitedRole = RoleType.None,
+				AccountId = newCreator
+			});
+
+			await ctx.SaveChangesAsync();
+
+			return await GetRoom(roomData.RoomId);
+		}
+
+		private static async Task<FullRoom?> GetDormTemplateRoom()
+		{
+			var templateRoom = await GetRoom(1);
+			if (templateRoom != null) return templateRoom;
+
+			await using var ctx = await DbFactory.CreateDbContextAsync();
+			var template = await ctx.Rooms.AsNoTracking().FirstOrDefaultAsync(room => room.IsDorm && room.CreatorAccountId == 1);
+			return template == null ? null : await GetRoom(template.RoomId);
+		}
+
+		public static async Task<FullRoom?> GetOrCreateDorm(long playerId)
+		{
+			await using var ctx = await DbFactory.CreateDbContextAsync();
+
+			var roomData = await ctx.Rooms.AsNoTracking().FirstOrDefaultAsync((x) => x.IsDorm && x.CreatorAccountId == playerId);
+			if (roomData == null)
+			{
+				var templateRoom = await GetDormTemplateRoom();
+				if (templateRoom == null)
+				{
+					return null;
+				}
+
+				return await CloneRoom(templateRoom.RoomId, playerId, "DormRoom");
+			}
+
+
+			var hasSubRoom = await ctx.SubRooms.AnyAsync(s => s.RoomId == roomData.RoomId);
+			if (!hasSubRoom)
+			{
+				var templateRoom = await GetDormTemplateRoom();
+				var templateSub = templateRoom?.SubRooms?.FirstOrDefault();
+				if (templateSub != null)
+				{
+					await ctx.SubRooms.AddAsync(new SubRoom
+					{
+						RoomId       = roomData.RoomId,
+						DataBlob     = templateSub.DataBlob,
+						UnityAssetId = templateSub.UnityAssetId,
+						IsSandbox    = templateSub.IsSandbox,
+						UnitySceneId = templateSub.UnitySceneId,
+						MaxPlayers   = templateSub.MaxPlayers,
+						Name         = templateSub.Name,
+						Accessibility = templateSub.Accessibility
+					});
+					await ctx.SaveChangesAsync();
+				}
+			}
+
+			return await GetRoom(roomData.RoomId);
+		}
+	}
+}