Marco Baldwin
388 lines
16 KiB
C#
388 lines
16 KiB
C#
using DeluxeBackend.Controllers;
|
|
using DeluxeBackend.Models;
|
|
using DeluxeBackend.Services;
|
|
using Discord;
|
|
using Discord.Interactions;
|
|
using Discord.WebSocket;
|
|
using Microsoft.AspNetCore.Http.HttpResults;
|
|
using SkiaSharp;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Drawing;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Net.Http;
|
|
using System.Reflection.Metadata;
|
|
using System.Text.Json;
|
|
using System.Text.Json.Serialization;
|
|
using System.Threading.Tasks;
|
|
using static DeluxeBackend.Controllers.Api.CustomAvatarItemsController;
|
|
using static DeluxeBackend.Discord.Commands.Debug;
|
|
using static DeluxeBackend.Discord.Commands.ImportStuff;
|
|
using static DeluxeBackend.Enums;
|
|
using static DeluxeBackend.Extensions.RoomExtensions;
|
|
|
|
namespace DeluxeBackend.Discord.Commands
|
|
{
|
|
public class ImportStuff(ILiteDbService db, ICdnService cdn) : InteractionModuleBase<SocketInteractionContext>
|
|
{
|
|
private readonly DateTime _saveCutoffDate = new(2023, 6, 21);
|
|
private readonly JsonSerializerOptions _jsonOptions = new() { PropertyNameCaseInsensitive = true };
|
|
|
|
private bool IsAdmin()
|
|
{
|
|
return Context.User is SocketGuildUser guildUser && guildUser.Roles.Any(r => r.Id == Debug.AdminRole);
|
|
}
|
|
|
|
public class RecNetResult<T>
|
|
{
|
|
[JsonRequired]
|
|
public required List<T> Results { get; set; }
|
|
[JsonRequired]
|
|
public int TotalResults { get; set; } = 0;
|
|
}
|
|
|
|
[SlashCommand("import_room", ".")]
|
|
public async Task importRoom(IAttachment file)
|
|
{
|
|
await DeferAsync();
|
|
if (!IsAdmin())
|
|
{
|
|
await FollowupAsync("No");
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
Account account = db.Accounts.FindOne(x => x.Username == "Import");
|
|
if (account == null)
|
|
{
|
|
account = new()
|
|
{
|
|
Username = "Import",
|
|
DisplayName = "Import",
|
|
Birthday = DateOnly.MinValue,
|
|
ImageName = "DefaultProfileImage",
|
|
IsRecentHistoryVisible = false,
|
|
};
|
|
account.Roles.AddRange(["developer", "keepsake", "livekeepsakeeventroomsaveoverride", "betaroomcurrencycreator", "multiinstanceevent"]);
|
|
db.Accounts.Insert(account);
|
|
}
|
|
|
|
using var httpClient = new HttpClient();
|
|
httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {ServerConfig.RRToken}");
|
|
|
|
HttpResponseMessage testreq = await httpClient.GetAsync("https://accounts.rec.net/account/me");
|
|
if (testreq.StatusCode != HttpStatusCode.OK)
|
|
{
|
|
await FollowupAsync($"Error: Failed to authenticate with rec.net. (Status: {testreq.StatusCode})");
|
|
return;
|
|
}
|
|
|
|
var textData = await httpClient.GetStringAsync(file.Url);
|
|
List<string> logs = [];
|
|
int successCount = 0;
|
|
|
|
async Task ImportSave(SubRoom subroom, SubRoomData2023AndNewer subRoom2)
|
|
{
|
|
if (subRoom2.CurrentSave == null) return;
|
|
|
|
CurrentSave2023AndNewer? save = null;
|
|
|
|
if (subRoom2.CurrentSave.CreatedAt >= _saveCutoffDate)
|
|
{
|
|
HttpResponseMessage savesReq = await httpClient.GetAsync($"https://rooms.rec.net/rooms/{subRoom2.RoomId}/subrooms/{subRoom2.SubRoomId}/saves?skip=0&take=1000");
|
|
if (savesReq.StatusCode == HttpStatusCode.OK)
|
|
{
|
|
var rawSavesJson = await savesReq.Content.ReadAsStringAsync();
|
|
var savesResult = JsonSerializer.Deserialize<RecNetResult<CurrentSave2023AndNewer>>(rawSavesJson, _jsonOptions);
|
|
|
|
save = savesResult?.Results?
|
|
.Where(s => s != null && s.CreatedAt < _saveCutoffDate && !string.IsNullOrEmpty(s.DataBlob))
|
|
.OrderByDescending(s => s.CreatedAt)
|
|
.FirstOrDefault();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
save = subRoom2.CurrentSave;
|
|
}
|
|
|
|
if (save == null)
|
|
{
|
|
logs.Add($"`{subroom.Name}`: Room has no compatible classic save file.");
|
|
return;
|
|
}
|
|
|
|
SubRoomSave newSave = new()
|
|
{
|
|
SubRoomId = subroom.Id,
|
|
DataBlob = save.DataBlob,
|
|
SavedByAccountId = account.Id,
|
|
Description = $"Imported by @{Context.User.Username}"
|
|
};
|
|
|
|
if (save.UnityAssetId.HasValue)
|
|
{
|
|
var assetTypes = new[] { AssetBundleType.WindowsDesktop, AssetBundleType.MobileAndroid };
|
|
|
|
var distinctVersions = Enum.GetValues<AssetBundleVersion>().Cast<int>().Distinct();
|
|
|
|
foreach (var assetType in assetTypes)
|
|
{
|
|
foreach (var versionId in distinctVersions)
|
|
{
|
|
try
|
|
{
|
|
var assetUrl = $"https://rooms.rec.net/unity_assets/{save.UnityAssetId.Value}/{(int)assetType}/{versionId}";
|
|
var jsonString = await httpClient.GetStringAsync(assetUrl);
|
|
Unity2023AndNewer? u = JsonSerializer.Deserialize<Unity2023AndNewer>(jsonString, _jsonOptions);
|
|
|
|
if (u == null) continue;
|
|
|
|
UnityAssets unityAssets = db.UnityAssets.FindOne(x => x.Id == save.UnityAssetId.Value) ?? new UnityAssets { Id = save.UnityAssetId.Value };
|
|
|
|
if (!unityAssets.Assets.Any(a => a.Filename == u.Filename && a.Target == u.Target && a.Version == u.Version))
|
|
{
|
|
unityAssets.Assets.Add(new UnityAsset
|
|
{
|
|
Filename = u.Filename,
|
|
Target = u.Target,
|
|
Version = u.Version
|
|
});
|
|
db.UnityAssets.Upsert(unityAssets);
|
|
}
|
|
|
|
newSave.UnityAssetId = save.UnityAssetId.Value.ToString();
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
db.SubRoomSave.Insert(newSave);
|
|
subroom.CurrentSave = newSave;
|
|
db.SubRooms.Update(subroom);
|
|
}
|
|
|
|
async Task import(string inputLine)
|
|
{
|
|
string roomName = inputLine;
|
|
|
|
if (roomName.Contains("rec.net/room/"))
|
|
{
|
|
int markerIndex = roomName.IndexOf("rec.net/room/") + "rec.net/room/".Length;
|
|
roomName = roomName.Substring(markerIndex).Split('/')[0].Trim();
|
|
}
|
|
|
|
if (string.IsNullOrWhiteSpace(roomName)) return;
|
|
|
|
HttpResponseMessage roomData = await httpClient.GetAsync($"https://rooms.rec.net/rooms/?name={roomName}&include=1325");
|
|
if (roomData.StatusCode == HttpStatusCode.NotFound)
|
|
{
|
|
logs.Add($"`{roomName}`: Not found on rec.net");
|
|
return;
|
|
}
|
|
|
|
roomData.EnsureSuccessStatusCode();
|
|
string rawJson = await roomData.Content.ReadAsStringAsync();
|
|
RoomData2023AndNewer? room = JsonSerializer.Deserialize<RoomData2023AndNewer>(rawJson, _jsonOptions);
|
|
|
|
if (room == null)
|
|
{
|
|
logs.Add($"`{roomName}`: Failed to parse room metadata");
|
|
return;
|
|
}
|
|
|
|
if (room.Accessibility == RoomAccessibility.Private)
|
|
{
|
|
logs.Add($"`{roomName}`: Room is private.");
|
|
return;
|
|
}
|
|
|
|
if (room.CreatedAt >= _saveCutoffDate)
|
|
{
|
|
logs.Add($"`{roomName}`: Room metadata is too new (Created: {room.CreatedAt:yyyy-MM-dd}).");
|
|
return;
|
|
}
|
|
|
|
if (db.Rooms.FindOne(x => x.Name.Equals(roomName, StringComparison.InvariantCultureIgnoreCase)) != null)
|
|
{
|
|
logs.Add($"`{roomName}`: Already exists in the database.");
|
|
return;
|
|
}
|
|
|
|
Room newRoom = new()
|
|
{
|
|
Accessibility = RoomAccessibility.Public,
|
|
Name = $"{room.Name}",
|
|
Description = room.Description,
|
|
ImageName = room.ImageName,
|
|
CloningAllowed = false,
|
|
Creator = account,
|
|
CustomWarning = room.CustomWarning,
|
|
WarningMask = room.WarningMask,
|
|
IsDorm = room.Name == "DormRoom",
|
|
IsRRO = false,
|
|
};
|
|
|
|
RoomSupports roomSup = RoomSupports.None;
|
|
if (room.SupportsScreens) roomSup |= RoomSupports.Screens;
|
|
if (room.SupportsWalkVR) roomSup |= RoomSupports.WalkVR;
|
|
if (room.SupportsTeleportVR) roomSup |= RoomSupports.TeleportVR;
|
|
roomSup |= RoomSupports.Juniors;
|
|
|
|
newRoom.SupportedPlayerTypes = roomSup;
|
|
db.Rooms.Insert(newRoom);
|
|
|
|
foreach (SubRoomData2023AndNewer scene in room.SubRooms)
|
|
{
|
|
SubRoom newScene = new()
|
|
{
|
|
Room = newRoom,
|
|
LocationId = scene.UnitySceneId,
|
|
Name = scene.Name,
|
|
IsSandbox = scene.IsSandbox,
|
|
MaxPlayers = scene.MaxPlayers,
|
|
CanMatchmakeInto = scene.Accessibility == RoomAccessibility.Public
|
|
};
|
|
db.SubRooms.Insert(newScene);
|
|
await ImportSave(newScene, scene);
|
|
}
|
|
|
|
logs.Add($"`{roomName}`: Successfully imported.");
|
|
successCount++;
|
|
}
|
|
|
|
var lines = textData.Split(["\r\n", "\n"], StringSplitOptions.RemoveEmptyEntries);
|
|
foreach (string line in lines)
|
|
{
|
|
string cleanLine = line.Trim();
|
|
if (!string.IsNullOrEmpty(cleanLine))
|
|
{
|
|
await import(cleanLine);
|
|
}
|
|
}
|
|
|
|
string summary = $"**Import Summary:** {successCount} room(s) imported successfully.\n\n" + string.Join("\n", logs);
|
|
if (summary.Length > 2000)
|
|
{
|
|
summary = summary.Substring(0, 1950) + "\n*...Truncated due to Discord length limits.*";
|
|
}
|
|
|
|
await FollowupAsync(summary);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
await FollowupAsync($"Error (Exception): {ex.Message}");
|
|
}
|
|
}
|
|
|
|
|
|
[SlashCommand("import_custom_avatar_item", ".")]
|
|
public async Task importCustomAvatarItem(ulong RecNetPlayerId, ulong DeluxeId)
|
|
{
|
|
using var httpClient = new HttpClient();
|
|
using var noAuthHttpClient = new HttpClient();
|
|
|
|
httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {ServerConfig.RRToken}");
|
|
|
|
HttpResponseMessage testreq = await httpClient.GetAsync("https://accounts.rec.net/account/me");
|
|
if (testreq.StatusCode != HttpStatusCode.OK)
|
|
{
|
|
await FollowupAsync($"Error: Failed to authenticate with rec.net. (Status: {testreq.StatusCode})");
|
|
return;
|
|
}
|
|
await DeferAsync();
|
|
if (!IsAdmin())
|
|
{
|
|
await FollowupAsync("No");
|
|
return;
|
|
}
|
|
|
|
Account? importAccount = db.Accounts.FindById(DeluxeId);
|
|
if (importAccount == null)
|
|
{
|
|
await FollowupAsync($"Error: No account found with Deluxe ID {DeluxeId}.");
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
HttpResponseMessage savesReq = await httpClient.GetAsync($"https://api.rec.net/api/customAvatarItems/v2/fromCreator/{RecNetPlayerId}?take=1000");
|
|
savesReq.EnsureSuccessStatusCode();
|
|
|
|
var Result = JsonSerializer.Deserialize<RecNetResult<CAvatarItemDto>>(await savesReq.Content.ReadAsStringAsync(), _jsonOptions);
|
|
|
|
if (Result == null || Result.Results.Count == 0)
|
|
{
|
|
await FollowupAsync("No custom avatar items found for that user.");
|
|
return;
|
|
}
|
|
foreach (var item in Result.Results)
|
|
{
|
|
if (item != null && !string.IsNullOrEmpty(item.DesignFilename))
|
|
{
|
|
if (item.BaseAvatarItemId != null && item.BaseAvatarItemId != 2184)
|
|
{
|
|
}
|
|
|
|
using var response = await noAuthHttpClient.GetAsync($"https://cdn.rec.net/img/{item.DesignFilename}");
|
|
|
|
response.EnsureSuccessStatusCode();
|
|
|
|
using var stream = await response.Content.ReadAsStreamAsync();
|
|
|
|
string? remotePath = await cdn.UploadFile(stream, "img");
|
|
|
|
if (string.IsNullOrEmpty(remotePath))
|
|
{
|
|
await FollowupAsync($"Failed to upload design image for item `{item.Name}`. Skipping.");
|
|
continue;
|
|
}
|
|
|
|
using var response2 = await noAuthHttpClient.GetAsync($"https://cdn.rec.net/img/{item.ThumbnailImageFilename}");
|
|
|
|
response2.EnsureSuccessStatusCode();
|
|
|
|
using var stream2 = await response2.Content.ReadAsStreamAsync();
|
|
|
|
string? remotePath2 = await cdn.UploadFile(stream2, "img");
|
|
|
|
if (string.IsNullOrEmpty(remotePath2))
|
|
{
|
|
await FollowupAsync($"Failed to upload thumbnail image for item `{item.Name}`. Skipping.");
|
|
continue;
|
|
}
|
|
|
|
var customAvatarItem = new CustomAvatarItem
|
|
{
|
|
Id = item.CustomAvatarItemId,
|
|
Accessibility = item.Accessibility,
|
|
Creator = importAccount,
|
|
Name = item.Name,
|
|
Description = item.Description,
|
|
Price = item.Price,
|
|
BaseAvatarItemId = item.BaseAvatarItemId,
|
|
BaseAvatarItemColor = ColorTranslator.FromHtml(item.BaseAvatarItemColor),
|
|
DesignFilename = remotePath,
|
|
ThumbnailImageFilename = remotePath2,
|
|
PreviewOrientation = item.PreviewOrientation
|
|
};
|
|
db.CustomAvatarItems.Insert(customAvatarItem);
|
|
};
|
|
|
|
}
|
|
await FollowupAsync($"Successfully imported {Result.Results.Count} custom avatar item(s).");
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
await FollowupAsync($"Error (Exception): {ex.Message}");
|
|
}
|
|
}
|
|
}
|
|
} |