niko
3754 lines
163 KiB
C#
3754 lines
163 KiB
C#
using System;
|
|
using System.Numerics;
|
|
using System.Security.Principal;
|
|
using LiteDB;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Newtonsoft.Json;
|
|
using Campus_live_rewrite.api;
|
|
using Campus_live_rewrite.api.server;
|
|
using Campus_live_rewrite.api.server.Classes;
|
|
using Campus_live_rewrite.api.server.Classes.db_class;
|
|
using Campus_live_rewrite.Controllers;
|
|
using SixLabors.ImageSharp;
|
|
using static ImageMetadataDB;
|
|
|
|
namespace Campus_live_rewrite.api.dbs
|
|
{
|
|
public class PlayerDB
|
|
{
|
|
public static LiteDatabase PlayerDBFile = new LiteDatabase(Environment.CurrentDirectory + $"/Data/DBs/Players.db");
|
|
private static readonly Random random = new Random();
|
|
private static readonly object randLock = new object();
|
|
|
|
public static bool CreateAccount(Platforms platform, ulong platformId, string deviceId, ulong discord_id, out account_data account)
|
|
{
|
|
account = new account_data();
|
|
|
|
Console.WriteLine($"[CreateAccount] === START === platform={platform} platformId={platformId} deviceId='{deviceId}' discord_id={discord_id}");
|
|
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var maxId = col.FindAll().OrderByDescending(x => x.id).FirstOrDefault()?.id ?? 0;
|
|
ulong accid = maxId + 1;
|
|
account.accountId = accid;
|
|
string name = Utils.GetRandomName();
|
|
|
|
Console.WriteLine($"[CreateAccount] Assigning accid={accid} (maxId was {maxId}), generated name='{name}'");
|
|
|
|
account = new account_data
|
|
{
|
|
createdAt = DateTime.UtcNow,
|
|
identityFlags = 0,
|
|
isJunior = null,
|
|
personalPronouns = 0,
|
|
platforms = 0,
|
|
displayName = name,
|
|
username = name,
|
|
profileImage = "DefaultPFP.png",
|
|
accountId = accid
|
|
};
|
|
col.Insert(new player_data
|
|
{
|
|
playerid = account.accountId,
|
|
id = accid,
|
|
platform = platform,
|
|
//platformId = platformId,
|
|
CreatedInGame = true,
|
|
deviceId = new List<string>
|
|
{
|
|
deviceId
|
|
},
|
|
authtoken = Utils.GetRandomString(400),
|
|
password = "",
|
|
player = new player_info
|
|
{
|
|
Id = accid,
|
|
Username = account.username,
|
|
DisplayName = account.displayName,
|
|
XP = 0,
|
|
Level = 1,
|
|
created_at = account.createdAt,
|
|
bannerImage = Campus_live_rewrite.api.server.ConfigCampus.DefaultBannerImage,
|
|
profileImage = account.profileImage,
|
|
IsJunior = false,
|
|
AvoidJuniors = true,
|
|
PlayerReputation = new mPlayerReputation
|
|
{
|
|
Noteriety = 0,
|
|
CheerCredit = 20,
|
|
CheerGeneral = 1,
|
|
CheerHelpful = 1,
|
|
CheerGreatHost = 1,
|
|
CheerSportsman = 1,
|
|
CheerCreative = 1,
|
|
SubscriberCount = 0,
|
|
SubscribedCount = 0,
|
|
SelectedCheer = CheerCategoryEnum.None
|
|
},
|
|
PlatformIds = new List<mPlatformID>
|
|
{
|
|
new mPlatformID
|
|
{
|
|
Platform = platform,
|
|
PlatformId = platformId
|
|
}
|
|
}
|
|
},
|
|
player_Extra = new player_extra
|
|
{
|
|
DormRoomID = 1,
|
|
IpAddresses = new List<string>(),
|
|
DiscordId = discord_id,
|
|
Bio = "",
|
|
avatar = "{\"FaceFeatures\": \"\",\"HairColor\": \"\",\"OutfitSelections\": \"\",\"SkinColor\": \"\"}",
|
|
SavedOutfits = new List<avatar_data_saved>(),
|
|
//ModerationBlockDetails = new Moderation_Detail.ModerationBlockDetails()
|
|
CheeredRooms = new List<ulong>(),
|
|
FavoritedRooms = new List<ulong>(),
|
|
sub_count = 0,
|
|
SubbedTo = new List<ulong>(),
|
|
IsRecentRoomHistoryVisible = true,
|
|
Influencer = new Influencer
|
|
{
|
|
creatorCode = "",
|
|
isInfluencer = false,
|
|
},
|
|
CustomAvatarItems = new Campus_live_rewrite.api.server.Classes.db_class.CustomAvatarItems(),
|
|
},
|
|
dev_Flag = DevFlag.none
|
|
});
|
|
//Settings.SaveSettings_db(Settings.CreateDefaultSettings(), accid);
|
|
Console.WriteLine($"[CreateAccount] Row inserted. accid={accid} platform={platform} discord_id={discord_id} display='{name}' img='{account.profileImage}'");
|
|
HeartbeatDB.CreatePlayerHeartbeat(accid, out _, platform, DeviceClasses.Unknown);
|
|
Console.WriteLine($"[CreateAccount] Heartbeat created for accid={accid}");
|
|
CreateDormForPlayerId(accid);
|
|
Console.WriteLine($"[CreateAccount] Dorm created for accid={accid}. === DONE ===");
|
|
return true;
|
|
}
|
|
|
|
// ================================================================================
|
|
// WEBSITE ACCOUNT CREATION (Campus accounts are now made on the website, not in game)
|
|
//
|
|
// The game used to auto-create an account on first launch (AuthController
|
|
// grant_type=create_account). That path is disabled - accounts are made here, on the
|
|
// site, with a username + password the player chooses, and the game only ever LOGS IN
|
|
// to them. The account carries NO platform binding at creation: a browser has no Steam
|
|
// id. The Steam id is stamped on the account the first time the player signs in from
|
|
// the game (AccountLock.TryEnforceAndBind), which is what "locks the account to your
|
|
// Steam" means.
|
|
// ================================================================================
|
|
|
|
/// <summary>Case-insensitive username -> account id, or 0 if no such account.</summary>
|
|
public static ulong GetAccountIdByUsernameCI(string username)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(username)) return 0;
|
|
string want = username.Trim();
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var p = col.FindAll().FirstOrDefault(x =>
|
|
x?.player?.Username != null &&
|
|
string.Equals(x.player.Username, want, StringComparison.OrdinalIgnoreCase));
|
|
return p?.playerid ?? 0;
|
|
}
|
|
|
|
/// <summary>Case-insensitive: is this exact username already in use?</summary>
|
|
public static bool IsUsernameTaken(string username)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(username)) return true;
|
|
string want = username.Trim();
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
return col.FindAll().Any(p =>
|
|
p?.player?.Username != null &&
|
|
string.Equals(p.player.Username, want, StringComparison.OrdinalIgnoreCase));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create an account from the website. No device id, no platform binding - those are
|
|
/// stamped on the first in-game login. The account is marked onboarding-complete so the
|
|
/// game drops the player straight in (no first-run "make a room" / username / password
|
|
/// flow) since they already chose all of that here.
|
|
/// </summary>
|
|
public static bool CreateWebAccount(string username, string displayName, string password,
|
|
string? email, out account_data account, out string error,
|
|
bool isJunior = false, string? birthday = null)
|
|
{
|
|
account = new account_data();
|
|
error = "";
|
|
|
|
username = (username ?? "").Trim();
|
|
displayName = string.IsNullOrWhiteSpace(displayName) ? username : displayName.Trim();
|
|
|
|
if (IsUsernameTaken(username))
|
|
{
|
|
error = "That username is already taken.";
|
|
return false;
|
|
}
|
|
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var maxId = col.FindAll().OrderByDescending(x => x.id).FirstOrDefault()?.id ?? 0;
|
|
ulong accid = maxId + 1;
|
|
|
|
account = new account_data
|
|
{
|
|
createdAt = DateTime.UtcNow,
|
|
identityFlags = 0,
|
|
isJunior = isJunior,
|
|
personalPronouns = 0,
|
|
platforms = 0,
|
|
displayName = displayName,
|
|
username = username,
|
|
profileImage = "DefaultPFP.png",
|
|
accountId = accid
|
|
};
|
|
|
|
col.Insert(new player_data
|
|
{
|
|
playerid = accid,
|
|
id = accid,
|
|
platform = Platforms.All,
|
|
CreatedInGame = false,
|
|
deviceId = new List<string>(), // bound on first in-game login
|
|
authtoken = Utils.GetRandomString(400),
|
|
password = ClientSecurity.HashPassword(password),
|
|
player = new player_info
|
|
{
|
|
Id = accid,
|
|
Username = username,
|
|
DisplayName = displayName,
|
|
Email = string.IsNullOrWhiteSpace(email) ? null : email.Trim(),
|
|
Birthday = string.IsNullOrWhiteSpace(birthday) ? null : birthday.Trim(),
|
|
XP = 0,
|
|
Level = 1,
|
|
created_at = account.createdAt,
|
|
bannerImage = Campus_live_rewrite.api.server.ConfigCampus.DefaultBannerImage,
|
|
profileImage = account.profileImage,
|
|
IsJunior = isJunior,
|
|
// Juniors are placed among juniors (don't avoid them); adults avoid juniors by default.
|
|
AvoidJuniors = !isJunior,
|
|
PlayerReputation = new mPlayerReputation
|
|
{
|
|
Noteriety = 0,
|
|
CheerCredit = 20,
|
|
CheerGeneral = 1,
|
|
CheerHelpful = 1,
|
|
CheerGreatHost = 1,
|
|
CheerSportsman = 1,
|
|
CheerCreative = 1,
|
|
SubscriberCount = 0,
|
|
SubscribedCount = 0,
|
|
SelectedCheer = CheerCategoryEnum.None
|
|
},
|
|
PlatformIds = new List<mPlatformID>() // NO steam id yet
|
|
},
|
|
player_Extra = new player_extra
|
|
{
|
|
DormRoomID = 1,
|
|
IpAddresses = new List<string>(),
|
|
DiscordId = 0,
|
|
Bio = "",
|
|
avatar = "{\"FaceFeatures\": \"\",\"HairColor\": \"\",\"OutfitSelections\": \"\",\"SkinColor\": \"\"}",
|
|
SavedOutfits = new List<avatar_data_saved>(),
|
|
CheeredRooms = new List<ulong>(),
|
|
FavoritedRooms = new List<ulong>(),
|
|
sub_count = 0,
|
|
SubbedTo = new List<ulong>(),
|
|
IsRecentRoomHistoryVisible = true,
|
|
Influencer = new Influencer { creatorCode = "", isInfluencer = false },
|
|
CustomAvatarItems = new Campus_live_rewrite.api.server.Classes.db_class.CustomAvatarItems(),
|
|
},
|
|
dev_Flag = DevFlag.none
|
|
});
|
|
|
|
HeartbeatDB.CreatePlayerHeartbeat(accid, out _, Platforms.All, DeviceClasses.Unknown);
|
|
CreateDormForPlayerId(accid);
|
|
|
|
// Mark first-run onboarding + tutorial complete so the game goes straight in - the
|
|
// player already chose username/password on the website (mirrors the Kyle seed in
|
|
// Program.cs and SettingsDB.CreateDefaultSettings).
|
|
SettingsDB.SetPlayerSetting("Recroom.AccountCreation.HasStarted", "true", accid);
|
|
SettingsDB.SetPlayerSetting("Recroom.AccountCreation.HasFinished", "true", accid);
|
|
SettingsDB.SetPlayerSetting("Recroom.AccountCreation.HasChosenUsername", "true", accid);
|
|
SettingsDB.SetPlayerSetting("Recroom.AccountCreation.HasCreatedPassword","true", accid);
|
|
SettingsDB.SetPlayerSetting("TUTORIAL_COMPLETE_MASK", "4294967295", accid);
|
|
|
|
Console.WriteLine($"[web-signup] created account {accid} @{username} (\"{displayName}\")"
|
|
+ (email != null ? " with email" : ""));
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The account's bound platform id for a platform (0 if none). Ignores the placeholder
|
|
/// 0 entry that some legacy rows carry.
|
|
/// </summary>
|
|
public static ulong GetAccountPlatformId(ulong accid, Platforms platform)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var p = col.FindOne(x => x.playerid == accid);
|
|
var ids = p?.player?.PlatformIds;
|
|
if (ids == null) return 0;
|
|
var match = ids.FirstOrDefault(pid => pid.Platform == platform && pid.PlatformId != 0);
|
|
return match?.PlatformId ?? 0;
|
|
}
|
|
|
|
/// <summary>Append a platform id to the account if it is not already present.</summary>
|
|
public static void AddPlatformId(ulong accid, Platforms platform, ulong platformId)
|
|
{
|
|
if (platformId == 0) return;
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var p = col.FindOne(x => x.playerid == accid);
|
|
if (p?.player == null) return;
|
|
p.player.PlatformIds ??= new List<mPlatformID>();
|
|
if (p.player.PlatformIds.Any(pid => pid.Platform == platform && pid.PlatformId == platformId))
|
|
return;
|
|
p.player.PlatformIds.Add(new mPlatformID { Platform = platform, PlatformId = platformId });
|
|
col.Update(p);
|
|
Console.WriteLine($"[account-lock] bound {platform} id {platformId} to account {accid}");
|
|
}
|
|
|
|
/// <summary>Every account carrying this platform id (used by the one-account-per-Steam lock).</summary>
|
|
public static List<ulong> AccountsWithPlatformId(Platforms platform, ulong platformId)
|
|
{
|
|
if (platformId == 0) return new List<ulong>();
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
return col.FindAll()
|
|
.Where(x => x.player?.PlatformIds != null &&
|
|
x.player.PlatformIds.Any(pid => pid.Platform == platform && pid.PlatformId == platformId))
|
|
.Select(x => x.playerid)
|
|
.ToList();
|
|
}
|
|
|
|
// ---- website signup rate limit -----------------------------------------------------
|
|
// One successful account creation per IP per ConfigCampus.SignupRateLimitDays (default 7).
|
|
// Persisted so a service restart does not reset the window. A tiny row per signup - the
|
|
// volume is human-scale, not request-scale.
|
|
public class WebSignupRecord
|
|
{
|
|
public int Id { get; set; }
|
|
public string? Ip { get; set; }
|
|
public ulong AccountId { get; set; }
|
|
public DateTime CreatedAt { get; set; }
|
|
}
|
|
|
|
/// <summary>The limiter's verdict: which layer refused, and when it frees up.</summary>
|
|
public enum SignupLimit { None, Ip, Subnet, Global }
|
|
|
|
/// <summary>
|
|
/// May this IP register right now? Checks, in order, the global per-hour cap, the per-IP
|
|
/// day/week caps and the /24 subnet cap (see ConfigCampus.SignupsPer*). On refusal says
|
|
/// which layer refused and the earliest time it frees up, so the caller can tell the
|
|
/// player something true. Blank/loopback/allowlisted IPs skip the per-address layers.
|
|
/// </summary>
|
|
public static SignupLimit CheckSignupLimit(string? ip, out DateTime nextAllowedUtc)
|
|
{
|
|
var now = DateTime.UtcNow;
|
|
nextAllowedUtc = now;
|
|
// Admin-allowlisted IPs test signup flows without tripping the caps (see
|
|
// ConfigCampus.AdminRateLimitEnabled).
|
|
if (AdminProtectionMiddleware.IsLimitExempt(ip)) return SignupLimit.None;
|
|
var col = PlayerDBFile.GetCollection<WebSignupRecord>("web_signups");
|
|
col.EnsureIndex(r => r.Ip);
|
|
col.EnsureIndex(r => r.CreatedAt);
|
|
|
|
// Global cap. This is a MASS-CREATION circuit breaker, not a growth cap, and for a
|
|
// long time it behaved as the latter: at 15/hour across every address on the internet
|
|
// it was the ONLY limit that ever fired. In one 12-hour window it refused 399 signups
|
|
// - 120 of them headsets retrying create_account, 34 distinct devices - while letting
|
|
// 19 through, and not one refusal came from the per-IP or per-subnet caps. Every real
|
|
// player who arrived after the 15th that hour was told "try again later"; on Quest
|
|
// that is a hard login failure the client then retries every ~8 s forever.
|
|
//
|
|
// So volume alone no longer trips it. Mass creation is CONCENTRATED - one actor behind
|
|
// a handful of networks - because the per-IP (1/day) and per-/24 (4/day) caps already
|
|
// bound what any single network can produce. Organic growth is DIFFUSE: a hundred
|
|
// strangers on a hundred networks. The breaker now fires only when an hour is both
|
|
// over the ceiling AND coming from few enough networks to be one actor.
|
|
if (ConfigCampus.SignupsPerHour > 0)
|
|
{
|
|
var hourAgo = now.AddHours(-1);
|
|
var lastHour = col.Find(r => r.CreatedAt >= hourAgo).OrderBy(r => r.CreatedAt).ToList();
|
|
if (lastHour.Count >= ConfigCampus.SignupsPerHour)
|
|
{
|
|
// Distinct networks behind the hour. An unattributable IP counts as its own
|
|
// network rather than being pooled with the other unattributable ones, so a
|
|
// flood cannot look diffuse just by stripping the address.
|
|
int networks = lastHour
|
|
.Select(r => SubnetKey(r.Ip) ?? ("ip:" + (r.Ip ?? "")))
|
|
.Distinct(StringComparer.OrdinalIgnoreCase)
|
|
.Count();
|
|
|
|
if (networks < ConfigCampus.SignupBurstDistinctNetworks)
|
|
{
|
|
nextAllowedUtc = lastHour[lastHour.Count - ConfigCampus.SignupsPerHour].CreatedAt.AddHours(1);
|
|
Console.WriteLine($"[signup-guard] GLOBAL cap tripped: {lastHour.Count} signups in the last hour " +
|
|
$"from only {networks} distinct network(s) - mass creation, not growth");
|
|
return SignupLimit.Global;
|
|
}
|
|
|
|
Console.WriteLine($"[signup-guard] {lastHour.Count} signups in the last hour across {networks} " +
|
|
$"distinct networks - over the ceiling but diffuse, allowed");
|
|
}
|
|
}
|
|
|
|
if (string.IsNullOrWhiteSpace(ip)) return SignupLimit.None;
|
|
ip = ip.Trim();
|
|
if (ip == "127.0.0.1" || ip == "::1" || ip == "localhost") return SignupLimit.None;
|
|
if (ConfigCampus.SignupExemptIps != null && ConfigCampus.SignupExemptIps.Contains(ip)) return SignupLimit.None;
|
|
|
|
var weekAgo = now.AddDays(-7);
|
|
var dayAgo = now.AddDays(-1);
|
|
var mine = col.Find(r => r.Ip == ip && r.CreatedAt >= weekAgo).OrderBy(r => r.CreatedAt).ToList();
|
|
|
|
if (ConfigCampus.SignupsPerIpPerWeek > 0 && mine.Count >= ConfigCampus.SignupsPerIpPerWeek)
|
|
{
|
|
nextAllowedUtc = mine[mine.Count - ConfigCampus.SignupsPerIpPerWeek].CreatedAt.AddDays(7);
|
|
return SignupLimit.Ip;
|
|
}
|
|
var mineToday = mine.Where(r => r.CreatedAt >= dayAgo).ToList();
|
|
if (ConfigCampus.SignupsPerIpPerDay > 0 && mineToday.Count >= ConfigCampus.SignupsPerIpPerDay)
|
|
{
|
|
nextAllowedUtc = mineToday[mineToday.Count - ConfigCampus.SignupsPerIpPerDay].CreatedAt.AddDays(1);
|
|
return SignupLimit.Ip;
|
|
}
|
|
|
|
// Network block - /24 for IPv4, /64 for IPv6. Same window as the per-IP day cap.
|
|
string? block = SubnetKey(ip);
|
|
if (block != null && ConfigCampus.SignupsPerSubnetPerDay > 0)
|
|
{
|
|
// Compare on the computed KEY, not a text prefix: one IPv6 address can be written
|
|
// several ways ("2001:db8::1" / "2001:db8:0:0::1"), so matching the stored string
|
|
// missed hosts that a real /64 comparison catches.
|
|
var inBlock = col.Find(r => r.CreatedAt >= dayAgo)
|
|
.Where(r => string.Equals(SubnetKey(r.Ip), block, StringComparison.OrdinalIgnoreCase))
|
|
.OrderBy(r => r.CreatedAt).ToList();
|
|
if (inBlock.Count >= ConfigCampus.SignupsPerSubnetPerDay)
|
|
{
|
|
nextAllowedUtc = inBlock[inBlock.Count - ConfigCampus.SignupsPerSubnetPerDay].CreatedAt.AddDays(1);
|
|
return SignupLimit.Subnet;
|
|
}
|
|
}
|
|
return SignupLimit.None;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The network an address belongs to: the /24 for IPv4, the /64 for IPv6, null when the
|
|
/// string is not an address at all.
|
|
///
|
|
/// IPv6 used to return null, so an IPv6 client had NO subnet cap - the per-/24 rule simply
|
|
/// did not apply to it and the global hourly ceiling was the only thing covering that
|
|
/// hole, which is part of why the ceiling had to be set so low. A /64 is what a
|
|
/// residential customer is handed, so it is the IPv6 equivalent of the /24 here.
|
|
/// </summary>
|
|
private static string? SubnetKey(string? ip)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(ip)) return null;
|
|
if (!System.Net.IPAddress.TryParse(ip.Trim(), out var addr)) return null;
|
|
var b = addr.GetAddressBytes();
|
|
|
|
if (addr.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
|
|
return "v4:" + b[0] + "." + b[1] + "." + b[2];
|
|
|
|
if (addr.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6)
|
|
{
|
|
var sb = new System.Text.StringBuilder("v6:");
|
|
for (int i = 0; i < 8; i++) sb.Append(b[i].ToString("x2")); // the /64 prefix
|
|
return sb.ToString();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static void RecordSignup(string? ip, ulong accountId)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<WebSignupRecord>("web_signups");
|
|
col.Insert(new WebSignupRecord
|
|
{
|
|
Ip = string.IsNullOrWhiteSpace(ip) ? "" : ip.Trim(),
|
|
AccountId = accountId,
|
|
CreatedAt = DateTime.UtcNow
|
|
});
|
|
}
|
|
|
|
public static bool ImportPlayers(string importPath)
|
|
{
|
|
Console.WriteLine($"[IMPORT] Starting player import");
|
|
Console.WriteLine($"[IMPORT] Import path: {importPath}");
|
|
|
|
try
|
|
{
|
|
if (!File.Exists(importPath))
|
|
{
|
|
Console.WriteLine($"[ERROR] Import file not found: {importPath}");
|
|
return false;
|
|
}
|
|
|
|
Console.WriteLine("[IMPORT] Reading import file...");
|
|
var json = File.ReadAllText(importPath);
|
|
Console.WriteLine($"[IMPORT] File size: {json.Length} bytes");
|
|
|
|
Console.WriteLine("[IMPORT] Deserializing player data...");
|
|
var importedPlayers = JsonConvert.DeserializeObject<List<player_data>>(json);
|
|
|
|
if (importedPlayers == null)
|
|
{
|
|
Console.WriteLine("[ERROR] Deserialization returned null (invalid JSON?)");
|
|
return false;
|
|
}
|
|
|
|
if (importedPlayers.Count == 0)
|
|
{
|
|
Console.WriteLine("[WARN] Import file contained 0 players");
|
|
return false;
|
|
}
|
|
|
|
Console.WriteLine($"[IMPORT] Players found in file: {importedPlayers.Count}");
|
|
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
|
|
int inserted = 0;
|
|
int skipped = 0;
|
|
|
|
foreach (var player in importedPlayers)
|
|
{
|
|
if (player == null)
|
|
{
|
|
Console.WriteLine("[WARN] Encountered null player entry, skipping");
|
|
skipped++;
|
|
continue;
|
|
}
|
|
|
|
Console.WriteLine($"[IMPORT] Processing player ID: {player.id}");
|
|
|
|
try
|
|
{
|
|
// Avoid duplicate IDs
|
|
if (col.Exists(x => x.id == player.id))
|
|
{
|
|
Console.WriteLine($"[SKIP] Duplicate player ID {player.id}");
|
|
skipped++;
|
|
continue;
|
|
}
|
|
player.player_Extra.DormRoomID = RoomDB.clone_dorm_room(player.playerid);
|
|
|
|
col.Insert(player);
|
|
var name = player.player.Username ?? "<unknown>";
|
|
var displayName = player.player.DisplayName ?? "<unknown>";
|
|
var displayEmoji = player.player.DisplayEmoji ?? "";
|
|
Console.WriteLine($"[OK] Inserted player ({player.id}) @{name} {displayName} {displayEmoji}");
|
|
inserted++;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"[ERROR] Failed to insert player ID {player.id}: {ex.Message}");
|
|
skipped++;
|
|
}
|
|
}
|
|
|
|
Console.WriteLine("[IMPORT] Import completed");
|
|
Console.WriteLine($"[IMPORT] Inserted: {inserted}");
|
|
Console.WriteLine($"[IMPORT] Skipped: {skipped}");
|
|
Console.WriteLine($"[IMPORT] Total processed: {importedPlayers.Count}");
|
|
|
|
return inserted > 0;
|
|
}
|
|
catch (JsonException jex)
|
|
{
|
|
Console.WriteLine($"[ERROR] JSON parsing error: {jex.Message}");
|
|
return false;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"[ERROR] Import failed with exception: {ex}");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static bool ExportPlayers(string exportPath)
|
|
{
|
|
try
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var allPlayers = col.FindAll().ToList();
|
|
|
|
var json = JsonConvert.SerializeObject(allPlayers, Formatting.Indented);
|
|
File.WriteAllText(exportPath, json);
|
|
|
|
Console.WriteLine($"Exported {allPlayers.Count} players to {exportPath}");
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"Export failed: {ex.Message}");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static bool CreateDormForPlayerId(ulong playerid, bool log = false)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
|
|
var player = col.FindOne(x => x.player.Id == playerid);
|
|
|
|
// Was: no null check, so an unknown player id threw here instead of
|
|
// reporting failure to the caller.
|
|
if (player == null)
|
|
{
|
|
Console.WriteLine($"[CreateDormForPlayerId] no player row for id {playerid}");
|
|
return false;
|
|
}
|
|
|
|
if (player.player_Extra != null)
|
|
{
|
|
ulong roomid = RoomDB.clone_dorm_room(playerid);
|
|
player.player_Extra.DormRoomID = roomid;
|
|
col.Update(player);
|
|
if (log)
|
|
{
|
|
Console.WriteLine($"Room id is {roomid} and successfully updaeted player");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public static void EnsureDormsForAllPlayers()
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
|
|
// Get all players
|
|
var players = col.FindAll();
|
|
|
|
foreach (var player in players)
|
|
{
|
|
if (player?.player == null || player.player_Extra == null)
|
|
continue;
|
|
|
|
// Missing or invalid dorm
|
|
if (player.player_Extra.DormRoomID == null || player.player_Extra.DormRoomID == 1)
|
|
{
|
|
ulong roomId = RoomDB.clone_dorm_room(player.player.Id);
|
|
player.player_Extra.DormRoomID = roomId;
|
|
col.Update(player);
|
|
Console.WriteLine($"Created dorm {roomId} for player {player.player.Id}");
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void EnsureDormsDontBeStupid(bool log = false)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var players = col.FindAll();
|
|
int fixCount = 0;
|
|
|
|
foreach (var player in players)
|
|
{
|
|
if (player?.player == null || player.player_Extra == null)
|
|
continue;
|
|
|
|
var room = RoomDB.GetRoom((ulong)player.player_Extra.DormRoomID);
|
|
|
|
// Check if the room is missing or simply isn't flagged as a Dorm
|
|
if (room == null || !room.IsDorm)
|
|
{
|
|
if (log)
|
|
{
|
|
string reason = (room == null) ? "Room Missing" : "Room not a Dorm";
|
|
Console.WriteLine($"[DormFix] Player: {player.player.Username} ({player.player.Id}) | Reason: {reason}");
|
|
}
|
|
|
|
CreateDormForPlayerId(player.player.Id);
|
|
fixCount++;
|
|
}
|
|
}
|
|
|
|
if (log && fixCount > 0)
|
|
{
|
|
Console.WriteLine($"[DormFix] Finished. Fixed {fixCount} player dorm records.");
|
|
}
|
|
}
|
|
|
|
|
|
public static ulong GetDormId(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
|
|
var player = col.FindOne(x => x.player.Id == playerid);
|
|
|
|
if (playerid == 1)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
// Was: dereferenced player.player_Extra with no null check, so an unknown
|
|
// player id threw NullReferenceException here.
|
|
if (player == null)
|
|
{
|
|
Console.WriteLine($"[GetDormId] no player row for id {playerid} - no dorm");
|
|
return 0;
|
|
}
|
|
|
|
if (player.player_Extra != null)
|
|
{
|
|
return (ulong)player.player_Extra.DormRoomID;
|
|
}
|
|
|
|
// Was: `return 1`. That is player 1's dorm, so any player whose row had no
|
|
// player_Extra was silently handed SOMEONE ELSE'S dorm room. 0 means "no
|
|
// dorm yet" and makes the caller create a real one.
|
|
Console.WriteLine($"[GetDormId] player {playerid} has no player_Extra - no dorm assigned yet");
|
|
return 0;
|
|
}
|
|
|
|
public static bool GetLogins(Platforms platform, ulong platformId, out List<AccountLogin> accounts)
|
|
{
|
|
accounts = new List<AccountLogin>();
|
|
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
|
|
// Pull all players (or consider filtering by another simple field if possible)
|
|
var allPlayers = col.FindAll().ToList();
|
|
|
|
// Filter in memory
|
|
var players = allPlayers
|
|
.Where(player => player.player.PlatformIds != null &&
|
|
player.player.PlatformIds.Any(pid => pid.Platform == platform &&
|
|
pid.PlatformId == platformId))
|
|
.ToList();
|
|
|
|
if (players.Count == 0)
|
|
return false;
|
|
|
|
foreach (var player in players)
|
|
{
|
|
var pid = player.player.PlatformIds.First(p => p.Platform == platform &&
|
|
p.PlatformId == platformId);
|
|
|
|
accounts.Add(new AccountLogin
|
|
{
|
|
accountId = player.playerid,
|
|
createdAt = player.player.created_at,
|
|
lastLoginTime = player.player.last_login_time,
|
|
platform = (Platforms)pid.Platform,
|
|
platformId = pid.PlatformId.ToString()
|
|
});
|
|
}
|
|
|
|
accounts = accounts
|
|
.OrderByDescending(a => a.lastLoginTime)
|
|
.ToList();
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
// A synthesized stand-in for an account id that has no DB row. Mirrors RecFlare's
|
|
// defaultAccount(): a "Player{id}" placeholder so the client can render a card instead
|
|
// of choking on a 404 / missing entry. The account_data_web getters supply the rest of
|
|
// the coalesced defaults (profileImage -> DefaultProfileImage.jpg, banner/emoji -> "").
|
|
private static account_data_web DefaultAccountWeb(ulong id)
|
|
{
|
|
// The login placeholder (see PlatformIdentity.LoginPlaceholderAccountId): the headset's
|
|
// cached-login picker asks for this id to label the "type your password" entry. Answer
|
|
// with a neutral identity, not "Player0" - that read as a real account failing to log in.
|
|
if (id == Campus_live_rewrite.api.server.PlatformIdentity.LoginPlaceholderAccountId)
|
|
return new account_data_web
|
|
{
|
|
accountId = id,
|
|
createdAt = DateTime.UtcNow,
|
|
username = Campus_live_rewrite.api.server.PlatformIdentity.LoginPlaceholderUsername,
|
|
displayName = Campus_live_rewrite.api.server.PlatformIdentity.LoginPlaceholderDisplayName,
|
|
profileImage = "DefaultPFP.png",
|
|
isJunior = false,
|
|
identityFlags = 0,
|
|
personalPronouns = 0,
|
|
platforms = 1 // Oculus - the platform the placeholder is served on
|
|
};
|
|
return new account_data_web
|
|
{
|
|
accountId = id,
|
|
createdAt = DateTime.UtcNow,
|
|
username = $"Player{id}",
|
|
displayName = $"Player{id}",
|
|
isJunior = false,
|
|
identityFlags = 0,
|
|
personalPronouns = 0,
|
|
platforms = 0
|
|
};
|
|
}
|
|
|
|
// A valid, non-negative `platforms` value for an account DTO. The account's primary
|
|
// platform int (Steam=0, Oculus=1, ...), or 0 if none is known. NEVER returns -1: the
|
|
// old code seeded a Platforms.All (-1) accumulator and OR'd onto it, so it was always
|
|
// -1, and -1 is not a real platform - the client's strict account parser rejects it and
|
|
// then NO player card / profile renders (own or others'). Same class as statusVisibility=4
|
|
// and deviceClass=-1.
|
|
public static long PrimaryPlatformValue(player_data? player)
|
|
{
|
|
var firstReal = player?.player?.PlatformIds?
|
|
.Select(p => (int)p.Platform)
|
|
.FirstOrDefault(v => v >= 0) ?? -1;
|
|
if (firstReal >= 0) return firstReal;
|
|
if (player != null && (int)player.platform >= 0) return (int)player.platform;
|
|
return 0;
|
|
}
|
|
|
|
public static string GetAccountsBulk(List<ulong> playerIds)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
col.EnsureIndex(x => x.id);
|
|
|
|
// ONE entry per requested id, in the requested set. A missing row is SYNTHESIZED
|
|
// (a Player{id} default), never dropped or 404'd - otherwise a profile / friends
|
|
// list / player list that references a deleted or never-existed id (e.g. the purged
|
|
// orphan ids 2,3,5) renders that card BLANK. This is exactly why single-account
|
|
// reads were 404ing (AccountById -> here -> empty array -> 404). Matches RecFlare's
|
|
// bulk, which guarantees one entry per requested id via defaultAccount().
|
|
var requested = playerIds?.Distinct().ToList() ?? new List<ulong>();
|
|
if (requested.Count == 0) return "[]";
|
|
|
|
var found = col.Find(x => requested.Contains(x.playerid))
|
|
.Where(p => p?.player != null)
|
|
.GroupBy(p => p.playerid)
|
|
.ToDictionary(g => g.Key, g => g.First());
|
|
|
|
var accounts = requested
|
|
.Select(id =>
|
|
{
|
|
if (!found.TryGetValue(id, out var player))
|
|
return DefaultAccountWeb(id);
|
|
|
|
// `platforms` MUST be a valid, non-negative number. It used to start at
|
|
// Platforms.All (-1) and OR onto it, so it was ALWAYS -1 - and -1 is not a
|
|
// real platform. The RecFlare account DTO emits a plain small number (0 by
|
|
// default; the reference never combines PlatformIds into it). A -1 here is
|
|
// the same out-of-range trap as statusVisibility=4 / deviceClass=-1: the
|
|
// client's strict account parser chokes on it and NO player card / profile
|
|
// renders (own or others'). Emit the account's primary platform int (Steam=0,
|
|
// Oculus=1, ...), defaulting to 0, never -1.
|
|
long platformsValue = 0;
|
|
var firstReal = player.player.PlatformIds?
|
|
.Select(p => (int)p.Platform)
|
|
.FirstOrDefault(v => v >= 0) ?? -1;
|
|
if (firstReal >= 0) platformsValue = firstReal;
|
|
else if ((int)player.platform >= 0) platformsValue = (int)player.platform;
|
|
|
|
return new account_data_web
|
|
{
|
|
accountId = player.playerid,
|
|
createdAt = player.player.created_at,
|
|
displayName = player.player.DisplayName,
|
|
displayEmoji = player.player.DisplayEmoji,
|
|
username = player.player.Username,
|
|
identityFlags = player.player.identityFlags,
|
|
isJunior = player.player.IsJunior,
|
|
personalPronouns = player.player.pronounFlags,
|
|
platforms = platformsValue,
|
|
profileImage = player.player.profileImage,
|
|
bannerImage = string.IsNullOrEmpty(player.player.bannerImage) ? Campus_live_rewrite.api.server.ConfigCampus.DefaultBannerImage : player.player.bannerImage
|
|
};
|
|
})
|
|
.OrderBy(a => a.accountId)
|
|
.ToList();
|
|
|
|
return JsonConvert.SerializeObject(accounts);
|
|
}
|
|
|
|
public static string GetAccountsBulkAdmin(List<ulong> playerIds)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
col.EnsureIndex(x => x.id);
|
|
|
|
var players = col.Find(x => playerIds.Contains(x.playerid)).ToList();
|
|
if (players.Count == 0)
|
|
{
|
|
return "[]";
|
|
}
|
|
|
|
var accounts = players
|
|
.Select(player =>
|
|
{
|
|
return new
|
|
{
|
|
accountId = player.playerid,
|
|
createdAt = player.player.created_at,
|
|
displayName = player.player.DisplayName,
|
|
displayEmoji = player.player.DisplayEmoji,
|
|
username = player.player.Username,
|
|
identityFlags = player.player.identityFlags,
|
|
isJunior = player.player.IsJunior,
|
|
personalPronouns = player.player.pronounFlags,
|
|
platforms = PrimaryPlatformValue(player),
|
|
profileImage = player.player.profileImage,
|
|
bannerImage = string.IsNullOrEmpty(player.player.bannerImage) ? Campus_live_rewrite.api.server.ConfigCampus.DefaultBannerImage : player.player.bannerImage,
|
|
bio = player.player_Extra.Bio,
|
|
mbd = JsonConvert.DeserializeObject(PlayerDB.Get_moderation_block(player.playerid)),
|
|
PlatformIDs = player.player.PlatformIds.Select(p => new
|
|
{
|
|
p.Platform,
|
|
PlatformId = p.PlatformId.ToString(),
|
|
// Username = Steam.GetAccountInfoAsync(p.PlatformId.ToString()).Result?.PersonaName ?? ""
|
|
}),
|
|
level = player.player.Level,
|
|
xp = player.player.XP
|
|
};
|
|
})
|
|
.OrderBy(a => a.accountId)
|
|
.ToList();
|
|
|
|
return JsonConvert.SerializeObject(accounts);
|
|
}
|
|
|
|
|
|
public static player_data? getfullaccount_token(ulong playerid, ulong platformid, int platform)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
if (player == null)
|
|
return null;
|
|
|
|
var ids = player.player.PlatformIds;
|
|
if (ids == null || ids.Count == 0)
|
|
return null;
|
|
|
|
bool match = ids.Any(p => p.PlatformId == platformid);
|
|
|
|
return match ? player : null;
|
|
}
|
|
|
|
/*public static player_data? GetFullAccount(ulong playerid, ulong plaformid, int plaform, string device_id)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
if (player == null)
|
|
{
|
|
return null;
|
|
}
|
|
if (player.platformId == plaformid && player.deviceId.Contains(device_id))
|
|
return player;
|
|
return null;
|
|
}
|
|
*/
|
|
|
|
public static player_data? GetFullAccount(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
|
|
if (player == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return player;
|
|
}
|
|
|
|
// ---- Currency balances ------------------------------------------------
|
|
// Stored per player in player_extra.Balances (CurrencyType -> amount).
|
|
|
|
public static long GetBalance(ulong playerId, int currencyType)
|
|
{
|
|
var acc = GetFullAccount(playerId);
|
|
if (acc?.player_Extra?.Balances == null) return 0;
|
|
return acc.player_Extra.Balances.TryGetValue(currencyType, out var v) ? v : 0;
|
|
}
|
|
|
|
public static Dictionary<int, long> GetAllBalances(ulong playerId)
|
|
{
|
|
var acc = GetFullAccount(playerId);
|
|
return acc?.player_Extra?.Balances ?? new Dictionary<int, long>();
|
|
}
|
|
|
|
/// <summary>Adds (or subtracts) an amount and returns the NEW balance. Clamped at 0.</summary>
|
|
public static long AddBalance(ulong playerId, int currencyType, long delta)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerId);
|
|
if (player == null) return 0;
|
|
|
|
player.player_Extra ??= new player_extra();
|
|
player.player_Extra.Balances ??= new Dictionary<int, long>();
|
|
|
|
long current = player.player_Extra.Balances.TryGetValue(currencyType, out var v) ? v : 0;
|
|
long updated = current + delta;
|
|
if (updated < 0) updated = 0;
|
|
player.player_Extra.Balances[currencyType] = updated;
|
|
|
|
col.Update(player);
|
|
return updated;
|
|
}
|
|
|
|
public static player_data? GetFullAccountByName(string username)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.player.Username == username);
|
|
|
|
if (player == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return player;
|
|
}
|
|
|
|
public static player_info? GetAccountById(ulong id)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
|
|
var player = col.FindById(id);
|
|
return player?.player;
|
|
}
|
|
|
|
public static account_data_me? GetAccountMeSafe(ulong playerid)
|
|
{
|
|
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
if (player == null)
|
|
{
|
|
return null;
|
|
}
|
|
// See PrimaryPlatformValue: a valid, non-negative platform number, NEVER -1 (which
|
|
// is what the old Platforms.All accumulator always produced and which breaks the
|
|
// client's account parser - the owner's OWN /account/me card wouldn't render).
|
|
account_data_me account = new account_data_me
|
|
{
|
|
accountId = player.playerid,
|
|
bannerImage = string.IsNullOrEmpty(player.player.bannerImage) ? Campus_live_rewrite.api.server.ConfigCampus.DefaultBannerImage : player.player.bannerImage,
|
|
createdAt = player.player.created_at,
|
|
displayName = player.player.DisplayName,
|
|
email = player.player.Email,
|
|
displayEmoji = player.player.DisplayEmoji,
|
|
username = player.player.Username,
|
|
identityFlags = player.player.identityFlags,
|
|
isJunior = player.player.IsJunior,
|
|
// Juniors are treated as juniors client-side (chat/social restrictions).
|
|
TreatAsJunior = player.player.IsJunior,
|
|
personalPronouns = player.player.pronounFlags,
|
|
platforms = PrimaryPlatformValue(player),
|
|
profileImage = player.player.profileImage,
|
|
};
|
|
// The client requires a present, valid birthday. Use the real one entered at signup
|
|
// when we have it; otherwise keep the fixed placeholder the DTO defaults to.
|
|
if (!string.IsNullOrWhiteSpace(player.player.Birthday))
|
|
{
|
|
account.birthday = player.player.Birthday;
|
|
account.hasBirthday = true;
|
|
}
|
|
else if (string.Equals(SettingsDB.GetPlayerSettingValue("Recroom.AccountCreation.HasFinished", player.playerid), "false", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
// An in-game account still in its creation flow with no birthday on record: tell
|
|
// the client so its title-screen account-creation flow (birthday -> avatar ->
|
|
// username -> password) has a page it cannot skip. Website accounts entered a
|
|
// birthday at signup and never hit this.
|
|
account.hasBirthday = false;
|
|
}
|
|
/*
|
|
account_data_me account = new account_data_me
|
|
{
|
|
accountId = player.playerid,
|
|
bannerImage = string.IsNullOrEmpty(player.player.bannerImage) ? Campus_live_rewrite.api.server.ConfigCampus.DefaultBannerImage : player.player.bannerImage,
|
|
createdAt = player.player.created_at,
|
|
displayName = player.player.DisplayName,
|
|
displayEmoji = player.player.DisplayEmoji,
|
|
username = player.player.Username,
|
|
identityFlags = player.player.identityFlags,
|
|
isJunior = player.player.IsJunior,
|
|
personalPronouns = player.player.pronounFlags,
|
|
platforms = (long)combinedPlatforms,
|
|
profileImage = player.player.profileImage,
|
|
};
|
|
*/
|
|
return account;
|
|
|
|
}
|
|
|
|
public static string Get_moderation_block(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
if (player == null)
|
|
{
|
|
return JsonConvert.SerializeObject(new Moderation_Detail.ModerationBlockDetails());
|
|
}
|
|
|
|
var block = player.player_Extra.ModerationBlockDetails;
|
|
|
|
// Only an ACTIVE penalty is a moderation block. A stored record with Duration <= 0 (or
|
|
// no set-time) is NOT active - e.g. a logged report with no penalty applied
|
|
// (IsBan=false, Duration=0). The client counts ANY non-empty moderationBlockDetails as a
|
|
// recent moderation incident and then blocks club/room creation ("Creation Restricted -
|
|
// too many moderation incidents"), so a non-active record MUST read back as empty.
|
|
if (block == null || block.Duration <= 0 || block.ModerationSetUnixTime <= 0)
|
|
return JsonConvert.SerializeObject(new Moderation_Detail.ModerationBlockDetails());
|
|
|
|
// Permanent ban.
|
|
if (block.Duration == int.MaxValue)
|
|
return JsonConvert.SerializeObject(block);
|
|
|
|
long now = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
|
|
int elapsed = (int)(now - block.ModerationSetUnixTime);
|
|
int remaining = block.Duration - elapsed;
|
|
|
|
if (remaining <= 0)
|
|
{
|
|
// Timeout has run out - clear it and report no block.
|
|
player.player_Extra.ModerationBlockDetails = null;
|
|
col.Update(player);
|
|
return JsonConvert.SerializeObject(new Moderation_Detail.ModerationBlockDetails());
|
|
}
|
|
|
|
// Still serving time: report the block with the time that's left.
|
|
block.Duration = remaining;
|
|
return JsonConvert.SerializeObject(block);
|
|
}
|
|
|
|
|
|
|
|
public static string Set_moderation_block(
|
|
ulong playerid,
|
|
Moderation_Detail.ReportCategory category,
|
|
int duration,
|
|
long gameSessionId,
|
|
bool? isHostKick,
|
|
string? message,
|
|
ulong? playerIdReporter,
|
|
bool? isBan,
|
|
ulong bannedByPlayerId,
|
|
bool addAppealMessage = true
|
|
)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
if (player == null)
|
|
return "{}";
|
|
if (addAppealMessage && isBan == true)
|
|
{
|
|
message += "\nTo appeal this ban, Make a ticket in https://discord.gg/xH8MMwK5Bk.";
|
|
}
|
|
var newBlock = new Moderation_Detail.ModerationBlockDetails
|
|
{
|
|
ReportCategory = category,
|
|
Duration = duration,
|
|
GameSessionId = gameSessionId,
|
|
IsHostKick = isHostKick,
|
|
Message = message,
|
|
PlayerIdReporter = playerIdReporter,
|
|
IsBan = isBan,
|
|
ModerationSetUnixTime = DateTimeOffset.UtcNow.ToUnixTimeSeconds(),
|
|
BannedByPlayerId = bannedByPlayerId
|
|
};
|
|
|
|
player.player_Extra.ModerationBlockDetails = newBlock;
|
|
col.Update(player);
|
|
|
|
// Every moderation action is logged with WHO did it to WHOM and why. Without this
|
|
// there is no way to tell a real moderator action from a bug calling this path -
|
|
// and a 1-second isBan looks identical to "the game keeps closing itself" from the
|
|
// player's side, because the block clears before anyone can inspect it.
|
|
Console.WriteLine(
|
|
$"[moderation] target={playerid} by={bannedByPlayerId} " +
|
|
$"isBan={isBan} isHostKick={isHostKick} duration={duration}s " +
|
|
$"category={category} reporter={playerIdReporter?.ToString() ?? "-"} " +
|
|
$"msg=\"{(message ?? "").Replace("\n", " ")}\"");
|
|
|
|
// A ban has to actually REMOVE them from the room.
|
|
//
|
|
// The client drops to its dorm and then resyncs against the presence heartbeat
|
|
// - and the heartbeat still said "you are in room X", so it put the banned
|
|
// player straight back into the room they were just banned from. Clearing the
|
|
// room instance means the resync has nowhere to send them.
|
|
if (isBan == true)
|
|
{
|
|
try
|
|
{
|
|
HeartbeatDB.UpdatePlayerHeartbeat(playerid, null, online: false);
|
|
Console.WriteLine($"[ban] cleared room instance for banned player {playerid}");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"[ban] could not clear heartbeat for {playerid}: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
Notifications.SendToPlayer(playerid, JsonConvert.SerializeObject(WebsocketEvents.CreateBan(newBlock)));
|
|
}
|
|
catch { }
|
|
|
|
return JsonConvert.SerializeObject(newBlock);
|
|
}
|
|
|
|
|
|
public static bool HasActiveModerationBlock(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
if (player == null)
|
|
return false;
|
|
|
|
var block = player.player_Extra.ModerationBlockDetails;
|
|
if (block == null || block.Duration <= 0 || block.ModerationSetUnixTime <= 0)
|
|
return false;
|
|
|
|
if (block.Duration == int.MaxValue) // Permanent ban
|
|
return true;
|
|
|
|
long now = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
|
|
int elapsed = (int)(now - block.ModerationSetUnixTime);
|
|
int remaining = block.Duration - elapsed;
|
|
|
|
if (remaining <= 0)
|
|
{
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static bool CheckDevFlag(ulong id)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.id == id);
|
|
|
|
if (player != null && (player.dev_Flag & DevFlag.dev) == DevFlag.dev)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public static bool CheckModFlag(ulong id)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.id == id);
|
|
|
|
if (player != null && (player.dev_Flag & DevFlag.mod) == DevFlag.mod)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public static void set_player_avatar(string avatar, ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player_Setting1 = col.FindOne(x => x.playerid == playerid);
|
|
// Was: guarded `player_Setting1.player != null` but then wrote to
|
|
// player_Setting1.player_Extra - the wrong field. A row with a null
|
|
// player_Extra threw NullReferenceException while saving the avatar.
|
|
if (player_Setting1?.player_Extra != null)
|
|
{
|
|
player_Setting1.player_Extra.avatar = avatar;
|
|
col.Update(player_Setting1);
|
|
return;
|
|
}
|
|
|
|
Console.WriteLine($"[set_player_avatar] no player_Extra for {playerid} - avatar not saved");
|
|
}
|
|
|
|
public static (bool Cheered, bool Favorited) GetInteraction(ulong playerid, ulong roomid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
if (player == null)
|
|
return (false, false);
|
|
|
|
bool cheered = player.player_Extra.CheeredRooms?.Contains(roomid) ?? false;
|
|
bool favorited = player.player_Extra.FavoritedRooms?.Contains(roomid) ?? false;
|
|
|
|
return (cheered, favorited);
|
|
}
|
|
|
|
public static bool ToggleCheer(ulong playerid, ulong roomid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
if (player == null) return false;
|
|
|
|
if (player.player_Extra.CheeredRooms == null)
|
|
player.player_Extra.CheeredRooms = new List<ulong>();
|
|
|
|
bool nowCheered;
|
|
if (player.player_Extra.CheeredRooms.Contains(roomid))
|
|
{
|
|
player.player_Extra.CheeredRooms.Remove(roomid);
|
|
nowCheered = false;
|
|
RoomDB.UpdateRoomCheerCount(roomid, -1);
|
|
}
|
|
else
|
|
{
|
|
player.player_Extra.CheeredRooms.Add(roomid);
|
|
nowCheered = true;
|
|
RoomDB.UpdateRoomCheerCount(roomid, +1);
|
|
}
|
|
|
|
col.Update(player);
|
|
return nowCheered;
|
|
}
|
|
|
|
public static bool ToggleFavorite(ulong playerid, ulong roomid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
if (player == null) return false;
|
|
|
|
if (player.player_Extra.FavoritedRooms == null)
|
|
player.player_Extra.FavoritedRooms = new List<ulong>();
|
|
|
|
bool nowFavorited;
|
|
if (player.player_Extra.FavoritedRooms.Contains(roomid))
|
|
{
|
|
player.player_Extra.FavoritedRooms.Remove(roomid);
|
|
nowFavorited = false;
|
|
RoomDB.UpdateRoomFavoriteCount(roomid, -1);
|
|
}
|
|
else
|
|
{
|
|
player.player_Extra.FavoritedRooms.Add(roomid);
|
|
nowFavorited = true;
|
|
RoomDB.UpdateRoomFavoriteCount(roomid, +1);
|
|
}
|
|
|
|
col.Update(player);
|
|
return nowFavorited;
|
|
}
|
|
|
|
public static List<account_data> Search(string text)
|
|
{
|
|
// GET /Accounts/account/search with no `name` query parameter passes null
|
|
// here, and the first thing the loop does is text.StartsWith("@") - an
|
|
// unhandled NullReferenceException that Kestrel turns into a 500.
|
|
// Verified live: probing the route with no argument returned HTTP 500.
|
|
// An empty search matches nothing, so return an empty list.
|
|
if (string.IsNullOrWhiteSpace(text))
|
|
return new List<account_data>();
|
|
|
|
// Match on USERNAME first (the reference server prefix-matches username, and the
|
|
// People search is by @handle), and also on DISPLAY NAME so searching the shown name
|
|
// works too. Case-insensitive Contains, which is a superset of the reference's prefix
|
|
// match. A leading "@" is stripped so "@eli" and "eli" behave the same.
|
|
//
|
|
// The previous version only checked username when the query STARTED WITH "@", and
|
|
// otherwise matched display name ONLY - so searching a plain "eli" (which is a
|
|
// USERNAME) never checked usernames and returned []. It also left `found=true` when a
|
|
// row had a null DisplayName, which quietly matched every such account.
|
|
string q = text.Trim().TrimStart('@').ToLowerInvariant();
|
|
if (q.Length == 0)
|
|
return new List<account_data>();
|
|
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
|
|
List<account_data> list = new List<account_data>();
|
|
foreach (player_data room in col.FindAll())
|
|
{
|
|
var p = room?.player;
|
|
if (p == null)
|
|
continue;
|
|
|
|
bool matchUsername = !string.IsNullOrEmpty(p.Username)
|
|
&& p.Username.ToLowerInvariant().Contains(q);
|
|
bool matchDisplay = !string.IsNullOrEmpty(p.DisplayName)
|
|
&& p.DisplayName.ToLowerInvariant().Contains(q);
|
|
|
|
if (!matchUsername && !matchDisplay)
|
|
continue;
|
|
|
|
var room_data = GetAccountBulk(room.playerid);
|
|
if (room_data is null)
|
|
continue;
|
|
list.Add(room_data);
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public static account_data GetAccountBulk(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
if (player == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return new account_data
|
|
{
|
|
accountId = player.playerid,
|
|
createdAt = player.player.created_at,
|
|
displayName = player.player.DisplayName,
|
|
username = player.player.Username,
|
|
identityFlags = 0,
|
|
isJunior = player.player.IsJunior,
|
|
personalPronouns = 0,
|
|
platforms = PrimaryPlatformValue(player),
|
|
profileImage = player.player.profileImage,
|
|
};
|
|
}
|
|
|
|
public static bool SetPlayerUsername(string username, ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
// Case-INSENSITIVE: "kyle" next to "Kyle" is the whole point of a spoofed @name.
|
|
var existingplayer = col.FindAll().FirstOrDefault(x => x.player?.Username != null
|
|
&& string.Equals(x.player.Username, username, StringComparison.OrdinalIgnoreCase) && x.playerid != playerid);
|
|
if (existingplayer != null)
|
|
{
|
|
return false;
|
|
}
|
|
var player_Setting1 = col.FindOne(x => x.playerid == playerid);
|
|
if (player_Setting1 != null)
|
|
{
|
|
if (player_Setting1.player != null)
|
|
{
|
|
player_Setting1.player.Username = username;
|
|
col.Update(player_Setting1);
|
|
RoomDB.RenameDormForPlayer(playerid);
|
|
Campus_live_rewrite.api.server.Notifications.FireAndForget(Campus_live_rewrite.api.server.Notifications.PushAccountUpdate(playerid), $"account-update {playerid}");
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Every platform id linked to this account for a platform, in the order stored.
|
|
/// An account may hold several - a player with two Steam accounts signs in on
|
|
/// either and lands here.
|
|
/// </summary>
|
|
public static List<ulong> GetPlatformIds(ulong playerid, Platforms platform)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var row = col.FindOne(x => x.playerid == playerid);
|
|
|
|
return row?.player?.PlatformIds?
|
|
.Where(p => p.Platform == platform)
|
|
.Select(p => p.PlatformId)
|
|
.ToList()
|
|
?? new List<ulong>();
|
|
}
|
|
|
|
/// <summary>First platform id for this platform, or 0. Convenience for display.</summary>
|
|
public static ulong GetPlatformId(ulong playerid, Platforms platform) =>
|
|
GetPlatformIds(playerid, platform).FirstOrDefault();
|
|
|
|
/// <summary>
|
|
/// Every account carrying this platform id, ignoring <paramref name="ignorePlayerId"/>.
|
|
///
|
|
/// Informational only - the admin panel reports shared ids rather than refusing
|
|
/// them. Sharing IS allowed by design, but it is worth knowing about: GetLogins
|
|
/// resolves a sign-in by (platform, platformId), so when several accounts hold the
|
|
/// same id, that lookup returns them all and the caller picks.
|
|
/// </summary>
|
|
public static List<ulong> FindPlayersByPlatformId(Platforms platform, ulong platformId, ulong ignorePlayerId = 0)
|
|
{
|
|
if (platformId == 0) return new List<ulong>();
|
|
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
return col.FindAll()
|
|
.Where(x => x.playerid != ignorePlayerId &&
|
|
x.player?.PlatformIds != null &&
|
|
x.player.PlatformIds.Any(p => p.Platform == platform && p.PlatformId == platformId))
|
|
.Select(x => x.playerid)
|
|
.ToList();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Replaces every link for this platform with <paramref name="platformIds"/>.
|
|
/// An empty list unlinks the platform entirely. Duplicates within the list are
|
|
/// collapsed; the same id living on OTHER accounts is left alone - that is
|
|
/// deliberate, several accounts may share one Steam id.
|
|
/// </summary>
|
|
public static bool SetPlatformIds(ulong playerid, Platforms platform, IEnumerable<ulong> platformIds)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var row = col.FindOne(x => x.playerid == playerid);
|
|
if (row?.player == null) return false;
|
|
|
|
row.player.PlatformIds ??= new List<mPlatformID>();
|
|
row.player.PlatformIds.RemoveAll(p => p.Platform == platform);
|
|
|
|
foreach (var id in platformIds.Where(i => i != 0).Distinct())
|
|
row.player.PlatformIds.Add(new mPlatformID { Platform = platform, PlatformId = id });
|
|
|
|
col.Update(row);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>Single-id form of <see cref="SetPlatformIds"/>; 0 unlinks.</summary>
|
|
public static bool SetPlatformId(ulong playerid, Platforms platform, ulong platformId) =>
|
|
SetPlatformIds(playerid, platform, platformId == 0 ? Array.Empty<ulong>() : new[] { platformId });
|
|
|
|
/// <summary>Sets (or with 0, clears) the linked Discord account.</summary>
|
|
public static bool SetDiscordId(ulong playerid, ulong discordId)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var row = col.FindOne(x => x.playerid == playerid);
|
|
if (row?.player == null) return false;
|
|
|
|
row.player_Extra ??= new player_extra();
|
|
row.player_Extra.DiscordId = discordId;
|
|
|
|
col.Update(row);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Finds whoever already has this Discord id linked, ignoring
|
|
/// <paramref name="ignorePlayerId"/>. Returns 0 when nobody does.
|
|
/// </summary>
|
|
public static ulong FindPlayerByDiscordId(ulong discordId, ulong ignorePlayerId = 0)
|
|
{
|
|
if (discordId == 0) return 0;
|
|
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var owner = col.FindAll().FirstOrDefault(x =>
|
|
x.playerid != ignorePlayerId &&
|
|
x.player_Extra != null &&
|
|
x.player_Extra.DiscordId == discordId);
|
|
|
|
return owner?.playerid ?? 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Link a Discord user to a Campus account (website Settings > Discord tab + the /link bot
|
|
/// command). Sets BOTH the id and the display tag. This is ONLY an association for the bot
|
|
/// and the site - it grants NO dev/admin/moderation privilege of any kind. Pass discordId 0
|
|
/// to unlink.
|
|
/// </summary>
|
|
public static bool SetDiscordLink(ulong playerid, ulong discordId, string? discordUsername)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
if (record?.player == null) return false;
|
|
record.player_Extra ??= new player_extra();
|
|
record.player_Extra.DiscordId = discordId;
|
|
record.player_Extra.DiscordUsername = discordId == 0 ? null : discordUsername;
|
|
col.Update(record);
|
|
Console.WriteLine($"[discord-link] account {playerid} {(discordId == 0 ? "UNLINKED" : $"linked to discord {discordId} ({discordUsername})")}");
|
|
return true;
|
|
}
|
|
|
|
/// <summary>Whether a moderator has locked this player's @name / display name (admin panel).</summary>
|
|
public static bool IsNameLocked(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
return record?.player_Extra?.NameLocked == true;
|
|
}
|
|
|
|
/// <summary>Lock or unlock a player's names. Admin edits are never gated by this.</summary>
|
|
public static bool SetNameLock(ulong playerid, bool locked)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
if (record?.player == null) return false;
|
|
record.player_Extra ??= new player_extra();
|
|
record.player_Extra.NameLocked = locked;
|
|
col.Update(record);
|
|
Console.WriteLine($"[names] account {playerid} (@{record.player.Username}) name lock {(locked ? "ON" : "off")}");
|
|
return true;
|
|
}
|
|
|
|
public static bool SetPlayerDev(DevFlag dev_Flag, ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var playerRecord = col.FindOne(x => x.playerid == playerid);
|
|
if (playerRecord != null)
|
|
{
|
|
if (playerRecord.player != null)
|
|
{
|
|
playerRecord.dev_Flag = dev_Flag;
|
|
col.Update(playerRecord);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static bool SetAllDev()
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
foreach (var playerRecord in col.FindAll())
|
|
{
|
|
if (playerRecord.player != null)
|
|
{
|
|
playerRecord.dev_Flag = DevFlag.dev;
|
|
col.Update(playerRecord);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static account_login<account_data> GetAccountPassword(string username, string password, bool isAdminPanel)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
|
|
if (string.IsNullOrWhiteSpace(username) || string.IsNullOrWhiteSpace(password))
|
|
{
|
|
return new account_login<account_data>
|
|
{
|
|
success = false,
|
|
error = "Your username or password is empty, please enter a username and password.",
|
|
};
|
|
}
|
|
|
|
var player = col.FindOne(x => x.player.Username == username);
|
|
if (player == null)
|
|
{
|
|
return new account_login<account_data>
|
|
{
|
|
success = false,
|
|
error = "The account you are trying to login to does not exist.",
|
|
};
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(player.password))
|
|
{
|
|
return new account_login<account_data>
|
|
{
|
|
success = false,
|
|
error = "The password or username you entered don't match the account you are trying to login to."
|
|
};
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(password))
|
|
{
|
|
return new account_login<account_data>
|
|
{
|
|
success = false,
|
|
error = "The password or username you entered don't match the account you are trying to login to.",
|
|
};
|
|
}
|
|
|
|
if (isAdminPanel)
|
|
{
|
|
var devCheckResult = PlayerDB.CheckDevFlag(player.playerid);
|
|
if (!devCheckResult)
|
|
{
|
|
return new account_login<account_data>
|
|
{
|
|
success = false,
|
|
error = "You are not a developer",
|
|
};
|
|
}
|
|
}
|
|
|
|
bool isValid = ClientSecurity.VerifyPassword(password, player.password);
|
|
|
|
if (!isValid)
|
|
{
|
|
string oldHash = ClientSecurity.GetHashString(password);
|
|
if (string.Equals(player.password, oldHash, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
player.password = ClientSecurity.HashPassword(password);
|
|
col.Update(player);
|
|
}
|
|
else
|
|
{
|
|
return new account_login<account_data>
|
|
{
|
|
success = false,
|
|
error = "The password or username you entered don't match the account you are trying to login to."
|
|
};
|
|
}
|
|
}
|
|
|
|
return new account_login<account_data>
|
|
{
|
|
success = true,
|
|
error = "",
|
|
accid = player.playerid,
|
|
};
|
|
}
|
|
|
|
public static void SetPlayerPassword(string pass, ulong playerid, bool log)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var playerRecord = col.FindOne(x => x.playerid == playerid);
|
|
if (playerRecord != null && playerRecord.player != null)
|
|
{
|
|
playerRecord.password = ClientSecurity.HashPassword(pass);
|
|
col.Update(playerRecord);
|
|
if (log)
|
|
{
|
|
Console.WriteLine($"[Password Change] PlayerID: {playerid} has changed their password.");
|
|
}
|
|
}
|
|
}
|
|
|
|
public static bool SetPlayerBio(string bio, ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
|
|
var player_Setting1 = col.FindOne(x => x.playerid == playerid);
|
|
if (player_Setting1 != null)
|
|
{
|
|
if (player_Setting1.player != null)
|
|
{
|
|
player_Setting1.player_Extra.Bio = bio;
|
|
col.Update(player_Setting1);
|
|
Campus_live_rewrite.api.server.Notifications.FireAndForget(Campus_live_rewrite.api.server.Notifications.PushAccountUpdate(playerid), $"account-update {playerid}");
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static async Task<bool> SetPlayerLevel(int level, ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
|
|
var player_Setting1 = col.FindOne(x => x.playerid == playerid);
|
|
if (player_Setting1 != null)
|
|
{
|
|
if (player_Setting1.player != null)
|
|
{
|
|
player_Setting1.player.Level = level;
|
|
try
|
|
{
|
|
await Notifications.SendToAll(JsonConvert.SerializeObject(WebsocketEvents.createResponse_levelupdate(playerid, level, Progress.CumulativeXpForLevel(level, 0))));
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
col.Update(player_Setting1);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static player_data? GetPlayerByDiscordId(ulong discordId)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.player_Extra.DiscordId == discordId);
|
|
return player;
|
|
}
|
|
|
|
public static void SetDisplayName(string username, ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player_Setting1 = col.FindOne(x => x.playerid == playerid);
|
|
if (player_Setting1 != null)
|
|
{
|
|
if (player_Setting1.player != null)
|
|
{
|
|
player_Setting1.player.DisplayName = username;
|
|
col.Update(player_Setting1);
|
|
Campus_live_rewrite.api.server.Notifications.FireAndForget(Campus_live_rewrite.api.server.Notifications.PushAccountUpdate(playerid), $"account-update {playerid}");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static bool SetRoleFlag(ulong playerid, DevFlag flag, bool enable)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
if (record == null) return false;
|
|
|
|
if (enable) record.dev_Flag |= flag;
|
|
else record.dev_Flag &= ~flag;
|
|
|
|
col.Update(record);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets XP and/or Level directly (admin panel). Pass null to leave one unchanged.
|
|
/// Returns the values actually stored, or null if the player does not exist.
|
|
/// </summary>
|
|
public static (int XP, int Level)? SetProgression(ulong playerid, int? xp, int? level)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
if (record?.player == null) return null;
|
|
|
|
if (xp.HasValue) record.player.XP = xp.Value < 0 ? 0 : xp.Value;
|
|
if (level.HasValue) record.player.Level = level.Value < 0 ? 0 : level.Value;
|
|
|
|
col.Update(record);
|
|
return (record.player.XP, record.player.Level);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Grants XP to a player and applies any level-ups it now pays for, using the real
|
|
/// progression curve (Progress.LEVEL_REQUIRED_XP). XP is progress INTO the current level;
|
|
/// a grant that fills the level carries the remainder forward. Returns the resulting
|
|
/// (Level, XP) and how many levels were gained, or null if the player has no row.
|
|
/// This is what a game reward calls - it was the missing piece: nothing granted XP, so
|
|
/// players never levelled up. Mirrors RecFlare's addXp.
|
|
/// </summary>
|
|
public static (int Level, int XP, int LevelsGained)? AddXp(ulong playerid, int amount)
|
|
{
|
|
if (amount <= 0)
|
|
{
|
|
var cur = Progress.GetPlayerLevel(playerid);
|
|
return (cur.Level, cur.XP, 0);
|
|
}
|
|
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
if (record?.player == null) return null;
|
|
|
|
int startLevel = record.player.Level < 1 ? 1 : record.player.Level;
|
|
int newXp = (record.player.XP < 0 ? 0 : record.player.XP) + amount;
|
|
|
|
var (level, xp) = Progress.ApplyLevelUps(startLevel, newXp);
|
|
int levelsGained = level - startLevel;
|
|
|
|
record.player.Level = level;
|
|
record.player.XP = xp;
|
|
col.Update(record);
|
|
|
|
// Push the new level/XP so the crown + progress bar update in real time (no relog) -
|
|
// AddXp used to be silent, so a level earned in-game only showed after a relog. A level
|
|
// CHANGE broadcasts (everyone's view of this player's crown updates); an XP-only gain
|
|
// pings just the owner so their bar advances. Same PlayerProgressionLevelUpdate event
|
|
// the admin level set + the progression GET use.
|
|
try
|
|
{
|
|
// Report CUMULATIVE XP (client derives the crown level from XP - see
|
|
// Progress.CumulativeXpForLevel), not the raw into-level XP.
|
|
int reportXp = Progress.CumulativeXpForLevel(level, xp);
|
|
string msg = JsonConvert.SerializeObject(WebsocketEvents.createResponse_levelupdate(playerid, level, reportXp));
|
|
if (levelsGained > 0) Notifications.FireAndForget(Notifications.SendToAll(msg), "levelup broadcast");
|
|
else Notifications.FireAndForget(Notifications.SendToPlayer(playerid, msg), "xp update");
|
|
}
|
|
catch { }
|
|
|
|
// Every level crossed pays its box (reference: grantLevelUpGifts). After the level is
|
|
// stored, so a failed roll costs a prize and not the level.
|
|
if (levelsGained > 0)
|
|
{
|
|
try { Campus_live_rewrite.api.server.LevelRewards.GrantLevelUps(playerid, startLevel, level); }
|
|
catch (Exception ex) { Console.WriteLine($"[levelrewards] {playerid}: {ex.Message}"); }
|
|
}
|
|
|
|
return (level, xp, levelsGained);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Claims a once-per-day reward. Returns false if it was already claimed today,
|
|
/// in which case nothing is written.
|
|
/// </summary>
|
|
public static bool TryClaimDailyReward(ulong playerid, string rewardKey)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
if (record == null) return false;
|
|
|
|
record.player_Extra ??= new player_extra();
|
|
record.player_Extra.DailyRewardClaims ??= new Dictionary<string, string>();
|
|
|
|
string today = DateTime.UtcNow.ToString("yyyy-MM-dd");
|
|
if (record.player_Extra.DailyRewardClaims.TryGetValue(rewardKey, out var last) && last == today)
|
|
return false;
|
|
|
|
record.player_Extra.DailyRewardClaims[rewardKey] = today;
|
|
col.Update(record);
|
|
return true;
|
|
}
|
|
|
|
// ---- Gift boxes -------------------------------------------------------
|
|
|
|
// ---- Avatar item ownership ------------------------------------------------
|
|
//
|
|
// The 2023 server treats AvatarItems.json as a CATALOG - the list of every item
|
|
// that exists - and keeps what each player owns on the player record, seeded from
|
|
// DefaultAvatarItems.json. The 2025 server had no ownership list at all and simply
|
|
// served the whole catalog from /api/avatar/v4/items, so everybody owned
|
|
// everything. These helpers restore the 2023 model.
|
|
|
|
/// <summary>
|
|
/// Canonical key for comparing two descriptors. Trailing empty colour slots are
|
|
/// dropped, so "guid,,," and "guid," compare equal, while "guid,colour,,"
|
|
/// stays distinct from "guid,,," - every colour of an item shares a base guid, so
|
|
/// keying on the guid alone would merge Knight Cape (Red) into Knight Cape (Green).
|
|
/// </summary>
|
|
public static string NormalizeAvatarItemDesc(string? desc)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(desc)) return "";
|
|
|
|
var parts = desc.Trim().Split(',').Select(p => p.Trim()).ToList();
|
|
while (parts.Count > 1 && string.IsNullOrEmpty(parts[^1])) parts.RemoveAt(parts.Count - 1);
|
|
|
|
// Compare on the EXPANDED form of every id.
|
|
//
|
|
// Rec Room writes ids two ways - a full UUID, or a 22-char base64 "short guid" -
|
|
// and avatar_items.json used to mix both. The catalog has since been rewritten to
|
|
// full UUIDs throughout (see Data/APIS/items/README-avatar-items.md), but stored
|
|
// ownership rows, DefaultAvatarItems.json and the storefronts still carry whichever
|
|
// spelling they were written with. Expanding here means "guid,8XajS2adOEOqzqnLy6-zcQ"
|
|
// and "guid,4ba376f1-9d66-4338-aace-a9cbcbafb371" are the same item, so nobody
|
|
// loses an item they own just because the catalog changed spelling.
|
|
for (int i = 0; i < parts.Count; i++)
|
|
{
|
|
var expanded = Campus_live_rewrite.api.server.Classes.ItemGuids.NormalizeGuid(parts[i]);
|
|
if (expanded != null) parts[i] = expanded;
|
|
}
|
|
|
|
return string.Join(",", parts);
|
|
}
|
|
|
|
/// <summary>
|
|
/// The starter wardrobe every non-developer account begins with. Loaded once.
|
|
/// </summary>
|
|
private static List<string>? _defaultAvatarItems;
|
|
private static readonly object _defaultAvatarItemsLock = new();
|
|
|
|
public static List<string> DefaultAvatarItemDescs()
|
|
{
|
|
if (_defaultAvatarItems != null) return _defaultAvatarItems;
|
|
|
|
lock (_defaultAvatarItemsLock)
|
|
{
|
|
if (_defaultAvatarItems != null) return _defaultAvatarItems;
|
|
|
|
var list = new List<string>();
|
|
try
|
|
{
|
|
string path = Path.Combine(Environment.CurrentDirectory, "Data", "APIS", "items", "DefaultAvatarItems.json");
|
|
if (File.Exists(path))
|
|
{
|
|
// The file is a flat array of descriptor strings.
|
|
var arr = Newtonsoft.Json.JsonConvert.DeserializeObject<List<string>>(File.ReadAllText(path));
|
|
foreach (var d in arr ?? new List<string>())
|
|
if (!string.IsNullOrWhiteSpace(d)) list.Add(d.Trim());
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine($"[items] DefaultAvatarItems.json not found at {path} - new accounts will start empty");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"[items] could not read DefaultAvatarItems.json: {ex.Message}");
|
|
}
|
|
|
|
_defaultAvatarItems = list;
|
|
Console.WriteLine($"[items] loaded {list.Count} default starter avatar item(s)");
|
|
return _defaultAvatarItems;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Everything this account owns, as canonical keys. Grants the starter set on
|
|
/// first read so existing accounts need no migration.
|
|
/// </summary>
|
|
public static HashSet<string> OwnedAvatarItemDescs(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
if (record == null) return new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
|
|
|
record.player_Extra ??= new player_extra();
|
|
|
|
if (record.player_Extra.AvatarItems == null)
|
|
{
|
|
record.player_Extra.AvatarItems = new List<string>(DefaultAvatarItemDescs());
|
|
col.Update(record);
|
|
Console.WriteLine($"[items] granted {record.player_Extra.AvatarItems.Count} starter item(s) to {playerid}");
|
|
}
|
|
|
|
var set = new HashSet<string>(
|
|
record.player_Extra.AvatarItems.Select(NormalizeAvatarItemDesc).Where(d => d.Length > 0),
|
|
StringComparer.OrdinalIgnoreCase);
|
|
|
|
// Unioned on READ rather than written into the wardrobe row, so every existing account
|
|
// gets it with no migration and it cannot drift out of sync with the catalog.
|
|
set.UnionWith(Campus_live_rewrite.api.server.HairGrants.FreeHairKeys());
|
|
return set;
|
|
}
|
|
|
|
/// <summary>Adds an item to a player's wardrobe. Returns true if it was new.</summary>
|
|
/// <summary>The normalised keys of every avatar item the player owns (defaults included).</summary>
|
|
public static HashSet<string> GetOwnedAvatarItemKeys(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
var items = record?.player_Extra?.AvatarItems ?? DefaultAvatarItemDescs();
|
|
var set = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
|
foreach (var d in items) { var k = NormalizeAvatarItemDesc(d); if (k.Length > 0) set.Add(k); }
|
|
set.UnionWith(Campus_live_rewrite.api.server.HairGrants.FreeHairKeys());
|
|
return set;
|
|
}
|
|
|
|
// Consumable descriptors come in short-guid and UUID spellings; own them by the UUID form.
|
|
public static string NormalizeConsumableDesc(string? desc)
|
|
{
|
|
string s = (desc ?? "").Trim();
|
|
if (s.Length == 0) return "";
|
|
return (Campus_live_rewrite.api.server.Classes.ItemGuids.NormalizeGuid(s) ?? s).ToLowerInvariant();
|
|
}
|
|
|
|
/// <summary>The player's consumable stock (desc key -> count), empty when they own none.</summary>
|
|
public static Dictionary<string, int> OwnedConsumables(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
return new Dictionary<string, int>(record?.player_Extra?.Consumables ?? new Dictionary<string, int>(), StringComparer.OrdinalIgnoreCase);
|
|
}
|
|
|
|
public static void GrantConsumable(ulong playerid, string? desc, int count)
|
|
{
|
|
string ck = NormalizeConsumableDesc(desc);
|
|
if (ck.Length == 0 || count <= 0) return;
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
if (record == null) return;
|
|
record.player_Extra ??= new player_extra();
|
|
record.player_Extra.Consumables ??= new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
|
|
record.player_Extra.Consumables[ck] = (record.player_Extra.Consumables.TryGetValue(ck, out var have) ? have : 0) + count;
|
|
col.Update(record);
|
|
}
|
|
|
|
public static bool GrantAvatarItem(ulong playerid, string? desc)
|
|
{
|
|
string key = NormalizeAvatarItemDesc(desc);
|
|
if (key.Length == 0) return false;
|
|
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
if (record == null) return false;
|
|
|
|
record.player_Extra ??= new player_extra();
|
|
record.player_Extra.AvatarItems ??= new List<string>(DefaultAvatarItemDescs());
|
|
|
|
if (record.player_Extra.AvatarItems.Any(d => NormalizeAvatarItemDesc(d).Equals(key, StringComparison.OrdinalIgnoreCase)))
|
|
return false;
|
|
|
|
record.player_Extra.AvatarItems.Add(desc!.Trim());
|
|
col.Update(record);
|
|
Console.WriteLine($"[items] granted '{desc!.Trim()}' to {playerid}");
|
|
return true;
|
|
}
|
|
|
|
/// <summary>Developers get the whole catalog - the dev locker.</summary>
|
|
public static bool HasDevLocker(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
return record != null && (record.dev_Flag & DevFlag.dev) == DevFlag.dev;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Marks CONTENTLESS pending gift boxes as opened, so they stop lingering forever. An empty
|
|
/// box (no gift drop, no avatar item, no consumable, no equipment) is filtered out of the
|
|
/// gifts list the client is sent - it can never be opened there and would sit in the DB
|
|
/// counting toward the gift badge as a "random gift" that won't clear. Marking it opened
|
|
/// retires it. Returns how many were retired.
|
|
/// </summary>
|
|
public static int MarkEmptyGiftBoxesOpened(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
var boxes = record?.player_Extra?.PendingGiftBoxes;
|
|
if (boxes == null || boxes.Count == 0) return 0;
|
|
|
|
int cleaned = 0;
|
|
foreach (var g in boxes)
|
|
{
|
|
if (g.Opened) continue;
|
|
// Currency / XP boxes count as content (a token box has no item and is real).
|
|
if (!Campus_live_rewrite.api.server.GiftBoxes.HasContent(g)) { g.Opened = true; cleaned++; }
|
|
}
|
|
|
|
if (cleaned > 0) col.Update(record);
|
|
return cleaned;
|
|
}
|
|
|
|
public static bool AddPendingGiftBox(ulong playerid, int giftContext, string? message, ulong fromAccountId = 0)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
if (record == null) return false;
|
|
|
|
record.player_Extra ??= new player_extra();
|
|
record.player_Extra.PendingGiftBoxes ??= new List<PendingGiftBox>();
|
|
record.player_Extra.PendingGiftBoxes.Add(new PendingGiftBox
|
|
{
|
|
GiftContext = giftContext,
|
|
Message = message,
|
|
FromAccountId = fromAccountId
|
|
});
|
|
|
|
col.Update(record);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>Stores a fully-populated gift box (store purchases carry item data).</summary>
|
|
/// <summary>Backfill a numeric Id onto any pending gift box that still has NumericId 0 (older
|
|
/// reward/select boxes). Without it the gifts endpoint emits a guid Id the client rejects.</summary>
|
|
// ---- gift package ids: ONE sequence for the whole server ------------------------------
|
|
//
|
|
// A gift box id has to be unique across PLAYERS, not just within one player's list. The
|
|
// client networks a spawned box into the room by its package id, and "Open All" walks the
|
|
// boxes it can see: with per-player ids (reward boxes 1001+ per player, purchases from a
|
|
// counter that restarted at 5000 on every deploy) two players' boxes in the same room
|
|
// shared ids. Player.log, opening gifts in the Rec Center after another player had: the
|
|
// client posts consume for 5003 and 5002 (the other player's, already opened - "no matching
|
|
// unopened box"), throws "Gift is missing from the list", and only then reaches its own
|
|
// 5004 - which the other player ALSO had as 5004. The reference's received_gift table is
|
|
// AUTOINCREMENT for the same reason.
|
|
//
|
|
// Seeded once above every id already stored, so nothing pending collides with a new box.
|
|
private sealed class Counter { public int Id { get; set; } public int Value { get; set; } }
|
|
private static readonly object _giftIdLock = new();
|
|
|
|
public static int NextGiftPackageId()
|
|
{
|
|
lock (_giftIdLock)
|
|
{
|
|
var counters = PlayerDBFile.GetCollection<Counter>("counters");
|
|
var row = counters.FindById(1);
|
|
if (row == null)
|
|
{
|
|
int max = 100_000;
|
|
try
|
|
{
|
|
foreach (var p in PlayerDBFile.GetCollection<player_data>("players").FindAll())
|
|
foreach (var b in p.player_Extra?.PendingGiftBoxes ?? new List<PendingGiftBox>())
|
|
if (b.NumericId > max) max = b.NumericId;
|
|
}
|
|
catch { }
|
|
row = new Counter { Id = 1, Value = max };
|
|
Console.WriteLine($"[gifts] gift package id sequence seeded at {max}");
|
|
}
|
|
row.Value++;
|
|
counters.Upsert(row);
|
|
return row.Value;
|
|
}
|
|
}
|
|
|
|
/// <summary>True when a box with this id is (or was) some OTHER player's.</summary>
|
|
public static bool GiftBoxBelongsToSomeoneElse(ulong playerid, int numericId)
|
|
{
|
|
try
|
|
{
|
|
foreach (var p in PlayerDBFile.GetCollection<player_data>("players").Find(x => x.playerid != playerid))
|
|
if ((p.player_Extra?.PendingGiftBoxes ?? new List<PendingGiftBox>()).Any(b => b.NumericId == numericId))
|
|
return true;
|
|
}
|
|
catch { }
|
|
return false;
|
|
}
|
|
|
|
public static void EnsureGiftBoxNumericIds(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
var boxes = record?.player_Extra?.PendingGiftBoxes;
|
|
if (boxes == null || boxes.Count == 0) return;
|
|
bool changed = false;
|
|
foreach (var b in boxes)
|
|
if (b.NumericId == 0) { b.NumericId = NextGiftPackageId(); changed = true; }
|
|
if (changed) col.Update(record);
|
|
}
|
|
|
|
// The guid is compared on its UUID form: Equipments.json spells every skin as a full UUID,
|
|
// but 112 of the 187 skin rows in the Watch store spell the SAME skins as 22-char short
|
|
// guids. Compared as text they never matched, so a bought skin was stored under a key
|
|
// that /equipment/v2/getUnlocked could never find - "Can't load item" on the box, and the
|
|
// skin never turned up in the locker.
|
|
public static string EquipmentSkinKey(string? prefab, string? guid)
|
|
{
|
|
string g = Campus_live_rewrite.api.server.Classes.ItemGuids.NormalizeGuid(guid) ?? (guid ?? "").Trim().ToLowerInvariant();
|
|
return $"{(prefab ?? "").Trim().ToLowerInvariant()}|{g}";
|
|
}
|
|
|
|
public static HashSet<string> OwnedEquipmentSkins(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
return new HashSet<string>(record?.player_Extra?.EquipmentSkins ?? new List<string>(), StringComparer.OrdinalIgnoreCase);
|
|
}
|
|
|
|
public static bool OwnsCustomItem(ulong playerid, string caid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
return record?.player_Extra?.CustomItems?.Any(c => string.Equals(c, caid, StringComparison.OrdinalIgnoreCase)) == true;
|
|
}
|
|
|
|
public static HashSet<string> OwnedCustomItems(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
return new HashSet<string>(record?.player_Extra?.CustomItems ?? new List<string>(), StringComparer.OrdinalIgnoreCase);
|
|
}
|
|
|
|
/// <summary>Put a UGC item in the player's wardrobe. Returns true if it was new.</summary>
|
|
public static bool GrantCustomItem(ulong playerid, string? caid)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(caid)) return false;
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
if (record == null) return false;
|
|
record.player_Extra ??= new player_extra();
|
|
record.player_Extra.CustomItems ??= new List<string>();
|
|
if (record.player_Extra.CustomItems.Any(c => string.Equals(c, caid, StringComparison.OrdinalIgnoreCase))) return false;
|
|
record.player_Extra.CustomItems.Add(caid);
|
|
col.Update(record);
|
|
Console.WriteLine($"[ugc] {playerid} now owns custom item {caid}");
|
|
return true;
|
|
}
|
|
|
|
/// <summary>Put a skin in the player's locker. Returns true if it was new.</summary>
|
|
public static bool GrantEquipmentSkin(ulong playerid, string? prefab, string? guid)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(prefab) || string.IsNullOrWhiteSpace(guid)) return false;
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
if (record == null) return false;
|
|
record.player_Extra ??= new player_extra();
|
|
record.player_Extra.EquipmentSkins ??= new List<string>();
|
|
string key = EquipmentSkinKey(prefab, guid);
|
|
if (record.player_Extra.EquipmentSkins.Any(k => string.Equals(k, key, StringComparison.OrdinalIgnoreCase))) return false;
|
|
record.player_Extra.EquipmentSkins.Add(key);
|
|
col.Update(record);
|
|
Console.WriteLine($"[skins] {playerid} now owns skin {prefab} {guid}");
|
|
return true;
|
|
}
|
|
|
|
public static bool AddPendingGiftBoxFull(ulong playerid, PendingGiftBox box)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
if (record == null) return false;
|
|
|
|
record.player_Extra ??= new player_extra();
|
|
record.player_Extra.PendingGiftBoxes ??= new List<PendingGiftBox>();
|
|
|
|
// Every gift box MUST have a numeric Id. The gifts endpoint emits the guid Id when
|
|
// NumericId is 0, but the client's gift model expects a NUMBER there and rejects the whole
|
|
// gifts array as "Malformed Response" if it sees a guid - which silently killed every
|
|
// reward gift box (and made the reward watch open then instantly close). Purchases already
|
|
// set NumericId; reward/select boxes didn't, so assign one here - from the server-wide
|
|
// sequence (NextGiftPackageId), never a per-player count.
|
|
if (box.NumericId == 0) box.NumericId = NextGiftPackageId();
|
|
|
|
record.player_Extra.PendingGiftBoxes.Add(box);
|
|
|
|
// A purchased or gifted item has to enter the wardrobe too, now that owning it
|
|
// is no longer implied by the catalog being served to everyone. Done here, in
|
|
// the same write, so a bought item can never be left unowned.
|
|
if (!string.IsNullOrWhiteSpace(box.AvatarItemDesc))
|
|
{
|
|
string key = NormalizeAvatarItemDesc(box.AvatarItemDesc);
|
|
record.player_Extra.AvatarItems ??= new List<string>(DefaultAvatarItemDescs());
|
|
|
|
if (!record.player_Extra.AvatarItems.Any(d =>
|
|
NormalizeAvatarItemDesc(d).Equals(key, StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
record.player_Extra.AvatarItems.Add(box.AvatarItemDesc!.Trim());
|
|
Console.WriteLine($"[items] {playerid} now owns '{box.AvatarItemDesc!.Trim()}' ({box.FriendlyName})");
|
|
}
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(box.CustomAvatarItemId))
|
|
{
|
|
record.player_Extra.CustomItems ??= new List<string>();
|
|
if (!record.player_Extra.CustomItems.Any(c => string.Equals(c, box.CustomAvatarItemId, StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
record.player_Extra.CustomItems.Add(box.CustomAvatarItemId!);
|
|
Console.WriteLine($"[ugc] {playerid} now owns custom item {box.CustomAvatarItemId} ({box.FriendlyName})");
|
|
}
|
|
}
|
|
|
|
// A consumable: counted into the player's own stock (was: everyone had every
|
|
// consumable with an infinite count, so nothing was ever really "got").
|
|
if (!string.IsNullOrWhiteSpace(box.ConsumableItemDesc))
|
|
{
|
|
record.player_Extra.Consumables ??= new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
|
|
string ck = NormalizeConsumableDesc(box.ConsumableItemDesc);
|
|
int add = box.ConsumableCount > 0 ? box.ConsumableCount : 1;
|
|
record.player_Extra.Consumables[ck] = (record.player_Extra.Consumables.TryGetValue(ck, out var have) ? have : 0) + add;
|
|
Console.WriteLine($"[consumables] {playerid} +{add} {box.FriendlyName} -> {record.player_Extra.Consumables[ck]}");
|
|
}
|
|
|
|
// An equipment SKIN enters the locker the same way an avatar item enters the wardrobe -
|
|
// in this write, so a bought skin can never be left unowned (it used to be: skins were
|
|
// served to everyone, so nothing ever recorded a purchase).
|
|
if (!string.IsNullOrWhiteSpace(box.EquipmentPrefabName) && !string.IsNullOrWhiteSpace(box.EquipmentModificationGuid))
|
|
{
|
|
record.player_Extra.EquipmentSkins ??= new List<string>();
|
|
string skey = EquipmentSkinKey(box.EquipmentPrefabName, box.EquipmentModificationGuid);
|
|
if (!record.player_Extra.EquipmentSkins.Any(k => string.Equals(k, skey, StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
record.player_Extra.EquipmentSkins.Add(skey);
|
|
Console.WriteLine($"[skins] {playerid} now owns skin {box.EquipmentPrefabName} {box.EquipmentModificationGuid} ({box.FriendlyName})");
|
|
}
|
|
}
|
|
|
|
col.Update(record);
|
|
return true;
|
|
}
|
|
|
|
public static List<PendingGiftBox> GetPendingGiftBoxes(ulong playerid)
|
|
{
|
|
var acc = GetFullAccount(playerid);
|
|
var all = acc?.player_Extra?.PendingGiftBoxes;
|
|
if (all == null) return new List<PendingGiftBox>();
|
|
return all.Where(g => !g.Opened).ToList();
|
|
}
|
|
|
|
// ================= Daily objectives / weekly challenges (quests) =================
|
|
// Per-player progress only - the objective/challenge CATALOG (descriptions, targets,
|
|
// rewards) is client-side. See APIController objectives + challenge handlers.
|
|
|
|
public static (List<ObjectiveProgress> objectives, List<ObjectiveGroupProgress> groups)
|
|
GetObjectivesProgress(ulong playerid)
|
|
{
|
|
var ex = GetFullAccount(playerid)?.player_Extra;
|
|
return (ex?.Objectives ?? new List<ObjectiveProgress>(),
|
|
ex?.ObjectiveGroups ?? new List<ObjectiveGroupProgress>());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Upsert one objective's progress on the (Group, Index) key. Returns true ONLY on the call
|
|
/// that first completes it while its reward is unclaimed - the once-only reward latch - so
|
|
/// the caller grants the reward exactly once. Hands back the parent group's state.
|
|
/// </summary>
|
|
public static bool UpdateObjective(ulong playerid, long group, int index,
|
|
double progress, double visualProgress, bool isCompleted,
|
|
out ObjectiveGroupProgress groupState)
|
|
{
|
|
groupState = new ObjectiveGroupProgress { Group = group };
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
if (record == null) return false;
|
|
|
|
record.player_Extra ??= new player_extra();
|
|
record.player_Extra.Objectives ??= new List<ObjectiveProgress>();
|
|
record.player_Extra.ObjectiveGroups ??= new List<ObjectiveGroupProgress>();
|
|
|
|
var o = record.player_Extra.Objectives.FirstOrDefault(x => x.Group == group && x.Index == index);
|
|
if (o == null)
|
|
{
|
|
o = new ObjectiveProgress { Group = group, Index = index };
|
|
record.player_Extra.Objectives.Add(o);
|
|
}
|
|
|
|
o.Progress = progress;
|
|
o.VisualProgress = visualProgress;
|
|
|
|
bool justCompleted = isCompleted && !o.HasClaimedReward;
|
|
if (isCompleted) o.IsCompleted = true;
|
|
if (justCompleted) o.HasClaimedReward = true;
|
|
|
|
var g = record.player_Extra.ObjectiveGroups.FirstOrDefault(x => x.Group == group);
|
|
if (g == null)
|
|
{
|
|
g = new ObjectiveGroupProgress { Group = group };
|
|
record.player_Extra.ObjectiveGroups.Add(g);
|
|
}
|
|
groupState = g;
|
|
|
|
col.Update(record);
|
|
return justCompleted;
|
|
}
|
|
|
|
public static ObjectiveGroupProgress ClearObjectiveGroup(ulong playerid, long group)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
var g = new ObjectiveGroupProgress { Group = group, IsCompleted = true, ClearedAt = DateTime.UtcNow.ToString("o") };
|
|
if (record == null) return g;
|
|
|
|
record.player_Extra ??= new player_extra();
|
|
record.player_Extra.ObjectiveGroups ??= new List<ObjectiveGroupProgress>();
|
|
var existing = record.player_Extra.ObjectiveGroups.FirstOrDefault(x => x.Group == group);
|
|
if (existing == null) { record.player_Extra.ObjectiveGroups.Add(g); }
|
|
else { existing.IsCompleted = true; existing.ClearedAt = g.ClearedAt; g = existing; }
|
|
|
|
col.Update(record);
|
|
return g;
|
|
}
|
|
|
|
public static HashSet<int> GetCompletedChallengeIds(ulong playerid, int mapId)
|
|
{
|
|
var set = new HashSet<int>();
|
|
var st = GetFullAccount(playerid)?.player_Extra?.ChallengeStatuses;
|
|
if (st != null)
|
|
foreach (var s in st)
|
|
if (s.ChallengeMapId == mapId && s.Complete) set.Add(s.ChallengeId);
|
|
return set;
|
|
}
|
|
|
|
/// <summary>Latch one challenge's completion within a rotation (false->true only). Returns the stored state.</summary>
|
|
public static bool RecordChallengeProgress(ulong playerid, int mapId, int challengeId, bool complete)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
if (record == null) return false;
|
|
|
|
record.player_Extra ??= new player_extra();
|
|
record.player_Extra.ChallengeStatuses ??= new List<ChallengeStatus>();
|
|
|
|
var s = record.player_Extra.ChallengeStatuses
|
|
.FirstOrDefault(x => x.ChallengeMapId == mapId && x.ChallengeId == challengeId);
|
|
if (s == null)
|
|
{
|
|
s = new ChallengeStatus { ChallengeMapId = mapId, ChallengeId = challengeId };
|
|
record.player_Extra.ChallengeStatuses.Add(s);
|
|
}
|
|
s.Complete = s.Complete || complete;
|
|
s.UpdatedAt = DateTime.UtcNow.ToString("o");
|
|
|
|
col.Update(record);
|
|
return s.Complete;
|
|
}
|
|
|
|
/// <summary>At-most-once gift claim for a challenge map. Returns true only on the FIRST claim.</summary>
|
|
public static bool ClaimChallengeGift(ulong playerid, int mapId)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
if (record == null) return false;
|
|
|
|
record.player_Extra ??= new player_extra();
|
|
record.player_Extra.ClaimedChallengeMaps ??= new List<int>();
|
|
if (record.player_Extra.ClaimedChallengeMaps.Contains(mapId)) return false;
|
|
|
|
record.player_Extra.ClaimedChallengeMaps.Add(mapId);
|
|
col.Update(record);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Opens (consumes) a gift box for a player. Returns the box that was opened, or null
|
|
/// when the player has no such unopened box.
|
|
///
|
|
/// The item was already granted at PURCHASE time (see AddPendingGiftBoxFull) - opening
|
|
/// is only the cosmetic reveal, so this just marks the box opened so it stops showing
|
|
/// as pending. Without this the client's POST /api/avatar/v2/gifts/consume 404'd, the
|
|
/// box was never marked opened, and GetPendingGiftBoxes handed it straight back - so a
|
|
/// box could be "opened" over and over and never went away.
|
|
///
|
|
/// The client sends back whatever id we emitted in the gifts list, which is NumericId
|
|
/// for purchases and the guid Id otherwise (see the Gifts endpoint), so match on both.
|
|
/// </summary>
|
|
/// <summary>Flip a box's PayOnOpen off. Returns true only for the call that flipped it.</summary>
|
|
public static bool ClearGiftBoxPayOnOpen(ulong playerid, PendingGiftBox box)
|
|
{
|
|
lock (_giftPayLock)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
var stored = record?.player_Extra?.PendingGiftBoxes?.FirstOrDefault(g =>
|
|
(box.NumericId != 0 && g.NumericId == box.NumericId) || (box.NumericId == 0 && g.Id == box.Id));
|
|
if (stored == null || (!stored.PayOnOpen && !stored.XpOnOpen)) return false;
|
|
stored.PayOnOpen = false; stored.XpOnOpen = false;
|
|
box.PayOnOpen = false; box.XpOnOpen = false;
|
|
col.Update(record);
|
|
return true;
|
|
}
|
|
}
|
|
private static readonly object _giftPayLock = new();
|
|
|
|
/// <summary>Persist PayOnOpen=true on an already-stored box.</summary>
|
|
public static void SetGiftBoxPayOnOpen(ulong playerid, PendingGiftBox box)
|
|
{
|
|
lock (_giftPayLock)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
var stored = record?.player_Extra?.PendingGiftBoxes?.FirstOrDefault(g =>
|
|
(box.NumericId != 0 && g.NumericId == box.NumericId) || (box.NumericId == 0 && g.Id == box.Id));
|
|
if (stored == null) return;
|
|
stored.PayOnOpen = true;
|
|
col.Update(record);
|
|
}
|
|
}
|
|
|
|
public static PendingGiftBox? ConsumeGiftBox(ulong playerid, string? id, int numericId)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
var boxes = record?.player_Extra?.PendingGiftBoxes;
|
|
if (boxes == null) return null;
|
|
|
|
var box = boxes.FirstOrDefault(g => !g.Opened &&
|
|
((numericId != 0 && g.NumericId == numericId) ||
|
|
(!string.IsNullOrEmpty(id) && g.Id == id)));
|
|
|
|
if (box == null) return null;
|
|
|
|
box.Opened = true;
|
|
col.Update(record);
|
|
Console.WriteLine($"[gifts] {playerid} opened box {(numericId != 0 ? numericId.ToString() : id)} ({box.FriendlyName})");
|
|
return box;
|
|
}
|
|
|
|
public static bool SetPlayerSteamId(ulong steamId, ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
if (record?.player == null) return false;
|
|
|
|
record.platform = Platforms.Steam;
|
|
record.player.PlatformIds ??= new List<mPlatformID>();
|
|
// Replace any existing Steam entry, add if missing.
|
|
var existing = record.player.PlatformIds.FirstOrDefault(p => p != null && p.Platform == Platforms.Steam);
|
|
if (existing != null) existing.PlatformId = steamId;
|
|
else record.player.PlatformIds.Add(new mPlatformID { Platform = Platforms.Steam, PlatformId = steamId });
|
|
col.Update(record);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>The account using this email (case-insensitive), or 0.</summary>
|
|
public static ulong GetAccountIdByEmail(string email)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(email)) return 0;
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var hit = col.FindAll().FirstOrDefault(x => x.player?.Email != null &&
|
|
string.Equals(x.player.Email.Trim(), email.Trim(), StringComparison.OrdinalIgnoreCase));
|
|
return hit?.playerid ?? 0;
|
|
}
|
|
|
|
public static bool SetPlayerEmail(string? email, ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var record = col.FindOne(x => x.playerid == playerid);
|
|
if (record?.player == null) return false;
|
|
record.player.Email = email;
|
|
col.Update(record);
|
|
return true;
|
|
}
|
|
|
|
public static bool SetLastLoginTime(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.player.Id == playerid);
|
|
if (player != null)
|
|
{
|
|
player.player.last_login_time = DateTime.UtcNow;
|
|
col.Update(player);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static bool ResetCheerCreditIfNewDay(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.player.Id == playerid);
|
|
|
|
if (player?.player?.PlayerReputation == null)
|
|
return false;
|
|
|
|
DateTime lastLoginDate = player.player.last_login_time.Date;
|
|
DateTime today = DateTime.UtcNow.Date;
|
|
|
|
if (lastLoginDate < today)
|
|
{
|
|
player.player.PlayerReputation.CheerCredit = 20;
|
|
player.player.last_login_time = DateTime.UtcNow;
|
|
|
|
col.Update(player);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
public static bool AddIpAddress(ulong playerid, string ip)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.player.Id == playerid);
|
|
if (player != null)
|
|
{
|
|
if (player.player_Extra.IpAddresses == null)
|
|
player.player_Extra.IpAddresses = new List<string>();
|
|
|
|
string encryptedIp = Utils.EncryptAes(ip);
|
|
|
|
if (!player.player_Extra.IpAddresses.Contains(encryptedIp))
|
|
player.player_Extra.IpAddresses.Add(encryptedIp);
|
|
|
|
col.Update(player);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
public static List<string> GetDecryptedIpAddresses(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.player.Id == playerid);
|
|
|
|
List<string> result = new();
|
|
if (player?.player_Extra?.IpAddresses != null)
|
|
{
|
|
foreach (string encryptedIp in player.player_Extra.IpAddresses)
|
|
{
|
|
try
|
|
{
|
|
result.Add(Utils.DecryptAes(encryptedIp));
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static void SetPlayerEmoji(string emoji, ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player_Setting1 = col.FindOne(x => x.playerid == playerid);
|
|
if (player_Setting1 != null)
|
|
{
|
|
if (player_Setting1.player != null)
|
|
{
|
|
player_Setting1.player.DisplayEmoji = emoji;
|
|
col.Update(player_Setting1);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void SetPlayerPronounFlags(int pronounflag, ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
|
|
var player_Setting1 = col.FindOne(x => x.playerid == playerid);
|
|
if (player_Setting1 != null)
|
|
{
|
|
if (player_Setting1.player != null)
|
|
{
|
|
player_Setting1.player.pronounFlags = pronounflag;
|
|
col.Update(player_Setting1);
|
|
}
|
|
else
|
|
{
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
}
|
|
}
|
|
public static void AddSubscription(ulong fromPlayerId, ulong toPlayerId)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var playerRecord = col.FindOne(x => x.playerid == fromPlayerId);
|
|
if (playerRecord == null || playerRecord.player_Extra == null)
|
|
throw new InvalidOperationException($"player_Extra for player {fromPlayerId} not found.");
|
|
|
|
// check if already subscribed
|
|
if (!playerRecord.player_Extra.SubbedTo.Contains(toPlayerId))
|
|
{
|
|
playerRecord.player_Extra.SubbedTo.Add(toPlayerId);
|
|
col.Update(playerRecord);
|
|
IncrementSubscriberCount(toPlayerId);
|
|
}
|
|
}
|
|
|
|
public static void IncrementSubscriberCount(ulong playerId)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerId);
|
|
if (player != null && player.player_Extra != null)
|
|
{
|
|
player.player_Extra.sub_count++;
|
|
col.Update(player);
|
|
}
|
|
}
|
|
|
|
public static void RemoveSubscription(ulong fromPlayerId, ulong toPlayerId)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var playerRecord = col.FindOne(x => x.playerid == fromPlayerId);
|
|
if (playerRecord == null || playerRecord.player_Extra == null)
|
|
return;
|
|
|
|
if (playerRecord.player_Extra.SubbedTo.Remove(toPlayerId))
|
|
{
|
|
col.Update(playerRecord);
|
|
DecrementSubscriberCount(toPlayerId);
|
|
}
|
|
}
|
|
|
|
public static void DecrementSubscriberCount(ulong playerId)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerId);
|
|
if (player != null && player.player_Extra != null && player.player_Extra.sub_count > 0)
|
|
{
|
|
player.player_Extra.sub_count--;
|
|
col.Update(player);
|
|
}
|
|
}
|
|
|
|
/// <summary>Everyone subscribed to <paramref name="playerId"/> (the creator's subscribers).</summary>
|
|
public static List<ulong> GetSubscriberIds(ulong playerId)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
return col.FindAll()
|
|
.Where(x => x.player_Extra?.SubbedTo != null && x.player_Extra.SubbedTo.Contains(playerId))
|
|
.Select(x => x.playerid)
|
|
.ToList();
|
|
}
|
|
|
|
public static List<ulong> GetSubscribedToIds(ulong playerId)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var playerRecord = col.FindOne(x => x.playerid == playerId);
|
|
if (playerRecord != null && playerRecord.player_Extra != null)
|
|
{
|
|
return playerRecord.player_Extra.SubbedTo;
|
|
}
|
|
return new List<ulong>();
|
|
}
|
|
|
|
public static void SetPlayerIdentityFlags(int IdentityFlag, ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player_Setting1 = col.FindOne(x => x.playerid == playerid);
|
|
if (player_Setting1 != null)
|
|
{
|
|
if (player_Setting1.player != null)
|
|
{
|
|
player_Setting1.player.identityFlags = IdentityFlag;
|
|
col.Update(player_Setting1);
|
|
}
|
|
else
|
|
{
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
}
|
|
}
|
|
|
|
public static void SetPlayerImageName(string imageName, ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
|
|
if (player?.player == null)
|
|
return;
|
|
|
|
player.player.profileImage = imageName;
|
|
col.Update(player);
|
|
Campus_live_rewrite.api.server.Notifications.FireAndForget(Campus_live_rewrite.api.server.Notifications.PushAccountUpdate(playerid), $"account-update {playerid}");
|
|
}
|
|
|
|
public static void SetPlayerBanner(string imageName, ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
|
|
if (player?.player == null)
|
|
return;
|
|
|
|
player.player.bannerImage = imageName;
|
|
col.Update(player);
|
|
}
|
|
|
|
public static int GetAccountCountByPlatformId(ulong platformId)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
|
|
return col.Count(x =>
|
|
x.player.PlatformIds != null &&
|
|
x.player.PlatformIds
|
|
.Select(pid => pid.PlatformId)
|
|
.Any(id => id == platformId)
|
|
);
|
|
}
|
|
public static int GetAccountCountByDiscordId(ulong discordId)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
|
|
return col.Count(x =>
|
|
x.player_Extra != null &&
|
|
x.player_Extra.DiscordId == discordId
|
|
);
|
|
}
|
|
|
|
public static List<ulong> GetAccountIdsByDiscordId(ulong discordId)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
|
|
return col
|
|
.Find(x =>
|
|
x.player_Extra != null &&
|
|
x.player_Extra.DiscordId == discordId
|
|
)
|
|
.Select(x => (ulong)x.playerid)
|
|
.ToList();
|
|
}
|
|
|
|
|
|
public static ulong GetPlayerCount()
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var players = col.FindAll().ToList();
|
|
|
|
if (players.Count == 0)
|
|
return 0;
|
|
|
|
ulong minID = players.Min(p => p.playerid);
|
|
ulong maxID = players.Max(p => p.playerid);
|
|
ulong expectedCount = (ulong)(maxID - minID + 1);
|
|
|
|
return expectedCount;
|
|
}
|
|
|
|
|
|
|
|
public static List<object> Find_all_player_filtered(string? id, string? displayName, string? minLevel, string? jrState, string? platformId, string? deviceId, bool onlyBannedPlayers)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players"); List<object> list = new List<object>();
|
|
|
|
foreach (player_data player in col.FindAll())
|
|
{
|
|
if (id != null && player.playerid.ToString() != id)
|
|
continue;
|
|
|
|
if (displayName != null && !player.player.DisplayName.Contains(displayName, StringComparison.OrdinalIgnoreCase))
|
|
continue;
|
|
|
|
if (minLevel != null && int.TryParse(minLevel, out int minLvl))
|
|
{
|
|
if (player.player.Level < minLvl)
|
|
continue;
|
|
}
|
|
|
|
if (jrState != null && jrState != "N/A")
|
|
{
|
|
bool expectedJunior = jrState == "true";
|
|
if (player.player.IsJunior != expectedJunior)
|
|
continue;
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(platformId) && (player.player.PlatformIds == null || !player.player.PlatformIds.Any(pid => pid.PlatformId.ToString() == platformId)))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (onlyBannedPlayers)
|
|
{
|
|
var block = player.player_Extra.ModerationBlockDetails;
|
|
if (block == null || block.IsBan != true || !HasActiveModerationBlock(player.playerid))
|
|
continue;
|
|
}
|
|
|
|
|
|
if (deviceId != null && !string.Equals(player.deviceId.ToString(), deviceId, StringComparison.OrdinalIgnoreCase))
|
|
continue;
|
|
|
|
var room_data = GetAccountBulk_full(player.playerid);
|
|
if (room_data != null)
|
|
list.Add(room_data);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
public static object? GetAccountBulk_full(ulong playerid)
|
|
{
|
|
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
List<object> list = new List<object>();
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
if (player == null)
|
|
{
|
|
return null;
|
|
}
|
|
// The admin row template reads `player.PlatformID` (singular) — surface the first
|
|
// non-zero linked platform id so accounts created via /create-account show up as
|
|
// "Steam 76561…" instead of "Steam undefined".
|
|
var firstPlatformId = player?.player?.PlatformIds?
|
|
.FirstOrDefault(p => p != null && p.PlatformId != 0)?.PlatformId.ToString();
|
|
|
|
// PlatformID above is the first non-zero id of ANY platform, so on a Quest
|
|
// account it is an Oculus id even though the admin table labels the column
|
|
// "Steam". The Steam allowlist must never be fed that, so surface the real
|
|
// Steam id separately - empty when the account has none.
|
|
var steamId = player?.player?.PlatformIds?
|
|
.FirstOrDefault(p => p != null && p.Platform == Platforms.Steam && p.PlatformId != 0)
|
|
?.PlatformId.ToString() ?? "";
|
|
|
|
return new
|
|
{
|
|
AccountId = player?.playerid,
|
|
Level = player?.player?.Level,
|
|
xp = player?.player?.XP,
|
|
DisplayName = player?.player?.DisplayName,
|
|
DeviceId = player?.deviceId,
|
|
Username = player?.player?.Username,
|
|
IsJunior = player?.player?.IsJunior,
|
|
ProfileImage = player?.player?.profileImage,
|
|
LastLoginTime = player?.player?.last_login_time,
|
|
CreatedAt = player?.player?.created_at,
|
|
PlatformID = firstPlatformId ?? "",
|
|
SteamID = steamId,
|
|
PlatformIDs = player?.player?.PlatformIds,
|
|
// Linked Discord (website Settings > Discord tab). Empty/0 when not linked.
|
|
DiscordUsername = player?.player_Extra?.DiscordUsername ?? "",
|
|
DiscordId = (player?.player_Extra?.DiscordId ?? 0) == 0 ? "" : (player!.player_Extra!.DiscordId).ToString(),
|
|
dormroom_id = player?.player_Extra?.DormRoomID,
|
|
DevFlagRaw = (int)(player?.dev_Flag ?? DevFlag.none),
|
|
IsDev = ((player?.dev_Flag ?? DevFlag.none) & DevFlag.dev) == DevFlag.dev,
|
|
IsMod = ((player?.dev_Flag ?? DevFlag.none) & DevFlag.mod) == DevFlag.mod,
|
|
IsScreenshare = ((player?.dev_Flag ?? DevFlag.none) & DevFlag.screenshare) == DevFlag.screenshare,
|
|
IsSupport = ((player?.dev_Flag ?? DevFlag.none) & DevFlag.support) == DevFlag.support,
|
|
IsInfluencer = player?.player_Extra?.Influencer?.isInfluencer == true,
|
|
};
|
|
}
|
|
|
|
public static void DeletePlayer(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
|
|
if (player != null)
|
|
{
|
|
col.Delete(playerid);
|
|
Console.WriteLine("Deleted player id " + playerid);
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine($"Player with ID {playerid} not found.");
|
|
}
|
|
}
|
|
|
|
public static int DeletePlayersWithNullLastLogin()
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
|
|
var minDate = DateTime.MinValue;
|
|
|
|
var playersToDelete = col
|
|
.Find(x => x.player.last_login_time == minDate)
|
|
.Select(x => x.playerid)
|
|
.ToList();
|
|
|
|
int deleted = 0;
|
|
|
|
foreach (var id in playersToDelete)
|
|
{
|
|
if (DeletePlayerFull(id))
|
|
deleted++;
|
|
}
|
|
|
|
Console.WriteLine($"Deleted {deleted} players with default LastLogin.");
|
|
|
|
return deleted;
|
|
}
|
|
|
|
|
|
public static bool DeletePlayerFull(ulong playerid)
|
|
{
|
|
try
|
|
{
|
|
DeletePlayer(playerid);
|
|
RoomDB.DeleteAllRoomsFromPlayerId(playerid);
|
|
HeartbeatDB.ClearPlayerHeartbeat(playerid);
|
|
SettingsDB.DeleteSettings(playerid);
|
|
LinkDB.DeleteLinksFromPlayerId(playerid);
|
|
ImageMetadataDB.DeleteImagesFromPlayerId(playerid);
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static string SetRecentRooms(ulong playerid, ulong room_id)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.player.Id == playerid);
|
|
|
|
if (player != null)
|
|
{
|
|
if (player.player.recent_rooms == null)
|
|
{
|
|
player.player.recent_rooms = new List<ulong>();
|
|
}
|
|
|
|
player.player.recent_rooms.Remove(room_id);
|
|
player.player.recent_rooms.Insert(0, room_id);
|
|
|
|
col.Update(player);
|
|
}
|
|
return "";
|
|
}
|
|
|
|
public static string GetRecentRooms(ulong playerId, int skip = 0, int take = 20)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.player.Id == playerId);
|
|
|
|
if (player == null || player.player.recent_rooms == null || !player.player.recent_rooms.Any())
|
|
{
|
|
return "[]";
|
|
}
|
|
|
|
var paginatedRoomIds = player.player.recent_rooms
|
|
.Skip(Math.Max(0, skip))
|
|
.Take(Math.Max(1, take))
|
|
.ToList();
|
|
|
|
var visitedRooms = new List<RoomDBClasses.RoomRoot>();
|
|
|
|
foreach (ulong roomId in paginatedRoomIds)
|
|
{
|
|
var room = RoomDB.GetRoom(roomId);
|
|
if (room != null)
|
|
{
|
|
visitedRooms.Add(room);
|
|
}
|
|
}
|
|
|
|
// Strip blobs the client cannot download - this listing is fetched moments
|
|
// before every join and the client can join straight from a cached entry.
|
|
Campus_live_rewrite.api.server.RoomBlobFilter.Strip(visitedRooms);
|
|
return JsonConvert.SerializeObject(visitedRooms, Formatting.None);
|
|
}
|
|
|
|
|
|
public static string ClearRecentRoomsForAllPlayers()
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
|
|
var allPlayers = col.FindAll();
|
|
|
|
foreach (var player in allPlayers)
|
|
{
|
|
if (player.player.recent_rooms != null && player.player.recent_rooms.Count > 0)
|
|
{
|
|
player.player.recent_rooms = new List<ulong>();
|
|
col.Update(player);
|
|
}
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
public static string GetFavoritedRooms(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.player.Id == playerid);
|
|
|
|
// Was: `player == null || player.player_Extra.FavoritedRooms == null` -
|
|
// if player_Extra itself was null the second clause threw NRE before the
|
|
// check could help.
|
|
if (player?.player_Extra?.FavoritedRooms == null)
|
|
{
|
|
return "[]";
|
|
}
|
|
|
|
var favRooms = new List<RoomDBClasses.RoomRoot>();
|
|
|
|
foreach (ulong roomId in player.player_Extra.FavoritedRooms)
|
|
{
|
|
var room = RoomDB.GetRoom(roomId);
|
|
if (room != null)
|
|
{
|
|
favRooms.Add(room);
|
|
}
|
|
}
|
|
|
|
return JsonConvert.SerializeObject(favRooms);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Records a device this account has logged in from. An account may accumulate
|
|
/// SEVERAL - a player is allowed to play on more than one machine, and each new
|
|
/// one is remembered the first time they sign in on it.
|
|
///
|
|
/// The restriction is on CREATION, not login: see CanCreateAccountOnDevice. A
|
|
/// device that already belongs to an account cannot be used to register another,
|
|
/// which is what stops alt farms, while a real player moving to a second device
|
|
/// just signs in and has it added here.
|
|
///
|
|
/// (This used to overwrite the list with a single id - one account, one device.
|
|
/// That made a legitimate second machine look like a device move on every login,
|
|
/// and it meant the creation check below had nothing reliable to test against.)
|
|
///
|
|
/// Blank ids are ignored rather than stored, so a login that sends no device id
|
|
/// cannot wipe the binding (and cannot create an unbannable empty-id account).
|
|
///
|
|
/// Device bans still work: AccountsOnDevice matches by CONTAINMENT, so banning a
|
|
/// device finds every account that has ever used it. Note the trade-off that comes
|
|
/// with allowing several devices - banning one does not stop a player who has
|
|
/// another registered.
|
|
/// </summary>
|
|
public static void SetPlayerDeviceId(string DeviceId, ulong playerid)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(DeviceId)) return;
|
|
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
if (player?.player == null) return;
|
|
|
|
string id = DeviceId.Trim();
|
|
var current = player.deviceId ?? new List<string>();
|
|
|
|
// Already known for this account - nothing to write.
|
|
if (current.Contains(id)) return;
|
|
|
|
current.Add(id);
|
|
player.deviceId = current;
|
|
col.Update(player);
|
|
|
|
Console.WriteLine($"[device] account {playerid} added device '{id}' "
|
|
+ $"({current.Count} total)");
|
|
}
|
|
|
|
/// <summary>Drop device bindings (the account lock replacing an idle device). The flat
|
|
/// anti-alt deviceId list is left alone: that device stays "used" for alt purposes.</summary>
|
|
public static void UnbindDevices(ulong playerid, IEnumerable<string> deviceIds)
|
|
{
|
|
var ids = new HashSet<string>(deviceIds, StringComparer.Ordinal);
|
|
if (ids.Count == 0) return;
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
if (player?.DeviceBindings == null) return;
|
|
int before = player.DeviceBindings.Count;
|
|
player.DeviceBindings.RemoveAll(b => b.DeviceId != null && ids.Contains(b.DeviceId));
|
|
if (player.DeviceBindings.Count != before) col.Update(player);
|
|
}
|
|
|
|
/// <summary>The account's device bindings (device id + the platform it signed in on).
|
|
/// Empty for legacy rows until the next login re-binds them.</summary>
|
|
public static List<mDeviceBind> GetDeviceBindings(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
return player?.DeviceBindings ?? new List<mDeviceBind>();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Record that this account signed in from this device on this platform. Writes BOTH the
|
|
/// flat deviceId list (the anti-alt source of truth) and the platform-aware DeviceBindings
|
|
/// list (used by the account lock's one-PC-one-Quest cap). Idempotent per (device,platform).
|
|
/// </summary>
|
|
public static void BindDevice(string? deviceId, Platforms platform, ulong playerid)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(deviceId)) return;
|
|
string id = deviceId.Trim();
|
|
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
if (player?.player == null) return;
|
|
|
|
bool changed = false;
|
|
|
|
var flat = player.deviceId ?? new List<string>();
|
|
if (!flat.Contains(id)) { flat.Add(id); player.deviceId = flat; changed = true; }
|
|
|
|
var binds = player.DeviceBindings ?? new List<mDeviceBind>();
|
|
var mine = binds.FirstOrDefault(b => b.DeviceId == id && b.Platform == platform);
|
|
if (mine == null)
|
|
{
|
|
binds.Add(new mDeviceBind { DeviceId = id, Platform = platform, LastSeen = DateTime.UtcNow });
|
|
player.DeviceBindings = binds;
|
|
changed = true;
|
|
}
|
|
else
|
|
{
|
|
// Touch: the account lock lets a NEW device of the same class take over when this
|
|
// one has been idle (AccountLock), so every login has to stamp it.
|
|
mine.LastSeen = DateTime.UtcNow;
|
|
player.DeviceBindings = binds;
|
|
changed = true;
|
|
}
|
|
|
|
if (changed)
|
|
{
|
|
col.Update(player);
|
|
Console.WriteLine($"[device] account {playerid} bound device '{id}' on {platform} "
|
|
+ $"({binds.Select(b => b.DeviceId).Distinct().Count()} device(s))");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clear an account's device bindings so it can be signed in from fresh hardware - the
|
|
/// operator's "reset" when a player legitimately replaces their PC or headset. Clears both
|
|
/// the flat deviceId list and the platform-aware DeviceBindings.
|
|
/// </summary>
|
|
public static bool ClearDeviceBindings(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
if (player == null) return false;
|
|
player.deviceId = new List<string>();
|
|
player.DeviceBindings = new List<mDeviceBind>();
|
|
col.Update(player);
|
|
Console.WriteLine($"[device] account {playerid} device bindings CLEARED");
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// May a NEW account be created from this device?
|
|
///
|
|
/// False once any existing account has used it. This is the whole anti-alt rule:
|
|
/// one account per device at creation time, while logins from further devices are
|
|
/// unrestricted (SetPlayerDeviceId).
|
|
///
|
|
/// A blank device id returns TRUE - it carries no information, and refusing on it
|
|
/// would lock out every caller that does not send one. Callers that care must
|
|
/// require a non-empty id themselves before asking.
|
|
/// </summary>
|
|
public static bool CanCreateAccountOnDevice(string? deviceId, out ulong existingAccountId)
|
|
{
|
|
existingAccountId = 0;
|
|
if (string.IsNullOrWhiteSpace(deviceId)) return true;
|
|
|
|
var owners = AccountsOnDevice(deviceId).Where(o => !AccountLock.IsExempt(o)).ToList();
|
|
if (owners.Count == 0) return true;
|
|
|
|
// A device may hold one game-made account and one website account (see
|
|
// ConfigCampus.MaxAccountsPerDevice). Creating in-game takes the game-made slot: refused
|
|
// once the device is full, or once it already has a game-made account.
|
|
existingAccountId = owners[0];
|
|
if (owners.Count >= ConfigCampus.MaxAccountsPerDevice) return false;
|
|
var gameMade = owners.FirstOrDefault(o => OriginOf(o) == AccountOrigin.InGame);
|
|
if (gameMade != 0) { existingAccountId = gameMade; return false; }
|
|
return true;
|
|
}
|
|
|
|
public enum AccountOrigin { Unknown, InGame, Website }
|
|
|
|
/// <summary>
|
|
/// Where an account was made. Rows created since the flag exists say so explicitly; older
|
|
/// rows are Unknown, and an Unknown account fits EITHER of a device's two slots (it only
|
|
/// counts toward the cap), so nobody who existed before the rule is locked out by it.
|
|
/// </summary>
|
|
public static AccountOrigin OriginOf(ulong accountId)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var p = col.FindOne(x => x.playerid == accountId);
|
|
if (p?.CreatedInGame == null) return AccountOrigin.Unknown;
|
|
return p.CreatedInGame.Value ? AccountOrigin.InGame : AccountOrigin.Website;
|
|
}
|
|
|
|
/// <summary>The account's single device id, or null if it has never logged in.</summary>
|
|
public static string? GetDeviceId(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
var list = player?.deviceId;
|
|
if (list == null || list.Count == 0) return null;
|
|
return string.IsNullOrWhiteSpace(list[0]) ? null : list[0];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Cached-login picker entries for the accounts bound to this device on this platform
|
|
/// (see ConfigCampus.QuestDeviceCachedLogin). requirePassword=false: device ownership is the
|
|
/// credential, the cached_login grant re-checks the same binding before issuing a token.
|
|
/// </summary>
|
|
public static List<AccountLogin> GetDeviceLogins(string? deviceId, Platforms platform, ulong platformId)
|
|
{
|
|
var result = new List<AccountLogin>();
|
|
if (string.IsNullOrWhiteSpace(deviceId)) return result;
|
|
string id = deviceId.Trim();
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
foreach (var p in col.FindAll())
|
|
{
|
|
if (p?.player == null || p.deviceId == null || !p.deviceId.Contains(id)) continue;
|
|
// Only a binding made from THIS platform class counts (a PC login on some shared
|
|
// device id must not turn into a headset cached login).
|
|
if (p.DeviceBindings == null || !p.DeviceBindings.Any(b => b.DeviceId == id && b.Platform == platform)) continue;
|
|
result.Add(new AccountLogin
|
|
{
|
|
accountId = p.playerid,
|
|
createdAt = p.player.created_at,
|
|
lastLoginTime = p.player.last_login_time,
|
|
platform = platform,
|
|
platformId = platformId.ToString(),
|
|
requirePassword = false
|
|
});
|
|
}
|
|
return result.OrderByDescending(a => a.lastLoginTime).ToList();
|
|
}
|
|
|
|
/// <summary>Is this account bound to this device on this platform?</summary>
|
|
public static bool IsDeviceBoundTo(ulong accountId, string? deviceId, Platforms platform)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(deviceId)) return false;
|
|
string id = deviceId.Trim();
|
|
var binds = GetDeviceBindings(accountId);
|
|
return binds.Any(b => b.DeviceId == id && b.Platform == platform);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Every account bound to this device id. Surfaced by the admin panel so a device
|
|
/// ban shows what else it takes out (alt accounts).
|
|
/// </summary>
|
|
public static List<ulong> AccountsOnDevice(string? deviceId)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(deviceId)) return new List<ulong>();
|
|
string id = deviceId.Trim();
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
return col.FindAll()
|
|
.Where(x => x.deviceId != null && x.deviceId.Contains(id))
|
|
.Select(x => x.playerid)
|
|
.ToList();
|
|
}
|
|
|
|
/// <summary>Clears an account-level ban. Device/IP bans are lifted separately (BanDB).</summary>
|
|
public static bool ClearModerationBlock(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
if (player?.player_Extra == null) return false;
|
|
|
|
player.player_Extra.ModerationBlockDetails = null;
|
|
col.Update(player);
|
|
return true;
|
|
}
|
|
public static void SetPlayerDiscordId(ulong DiscordId, ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
if (player != null)
|
|
{
|
|
if (player.player != null)
|
|
{
|
|
player.player_Extra.DiscordId = DiscordId;
|
|
col.Update(player);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static string GetPlayerNameById(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
return player?.player.Username ?? "Unknown";
|
|
}
|
|
|
|
public static ulong GetPlayerIdByName(string name)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.player.Username == name);
|
|
return player?.player.Id ?? 0;
|
|
}
|
|
|
|
public static string GetAvatarSaved(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
// Was: only `player` was null-checked, then player_Extra.SavedOutfits was
|
|
// dereferenced - NRE when player_Extra is null. And SerializeObject(null)
|
|
// returns the literal "null", not "[]", which the client cannot parse as a
|
|
// list. Both paths now yield a real empty array.
|
|
var saved = player?.player_Extra?.SavedOutfits;
|
|
if (saved == null || saved.Count == 0)
|
|
{
|
|
return "[]";
|
|
}
|
|
|
|
// The newer client's Saved Outfits page (SavedOutfitsWatchUIFlow) deserializes each
|
|
// outfit into the StoredOutfit envelope and THROWS "Expected LegacyData but was null"
|
|
// (DCJDHBOIBBC.MissingLegacyData) on any entry without a `LegacyData` object - which
|
|
// then blanks the whole page. Serializing the STRUCTURED avatar_data_saved (which has
|
|
// no LegacyData field) is exactly that failure. So project each outfit into the shape
|
|
// the client expects:
|
|
// - Preferred: round-trip the RAW document the client posted (SaveOutfit stores it in
|
|
// .Avatar); it already carries LegacyData/Selections/DataVersion verbatim.
|
|
// - Fallback (older saves / server-made presets with no raw body): synthesize the
|
|
// LegacyData envelope from the flat fields so LegacyData is never null.
|
|
var arr = new Newtonsoft.Json.Linq.JArray();
|
|
foreach (var o in saved)
|
|
{
|
|
Newtonsoft.Json.Linq.JObject? raw = null;
|
|
if (!string.IsNullOrWhiteSpace(o.Avatar))
|
|
{
|
|
try { raw = Newtonsoft.Json.Linq.JObject.Parse(o.Avatar); } catch { raw = null; }
|
|
}
|
|
|
|
if (raw != null && raw["LegacyData"] != null &&
|
|
raw["LegacyData"]!.Type != Newtonsoft.Json.Linq.JTokenType.Null)
|
|
{
|
|
// Slot/Name are the authority for slot overwrite - keep them in sync with the
|
|
// structured fields in case the stored raw body predated them.
|
|
raw["Slot"] = (long)o.Slot;
|
|
if (o.Name != null) raw["Name"] = o.Name;
|
|
arr.Add(raw);
|
|
continue;
|
|
}
|
|
|
|
arr.Add(new Newtonsoft.Json.Linq.JObject
|
|
{
|
|
["LegacyData"] = new Newtonsoft.Json.Linq.JObject
|
|
{
|
|
["SelectionsV1"] = o.OutfitSelections,
|
|
["SelectionsV2"] = o.OutfitSelectionsV2,
|
|
["FaceFeatures"] = o.FaceFeatures,
|
|
["SkinColor"] = o.SkinColor,
|
|
["HairColor"] = o.HairColor
|
|
},
|
|
["Selections"] = new Newtonsoft.Json.Linq.JArray(),
|
|
["DataVersion"] = 9,
|
|
["CustomizationSettings"] = (string?)null,
|
|
["ThumbnailFileName"] = o.ImageName ?? o.PreviewImageName,
|
|
["Name"] = o.Name,
|
|
["Accessibility"] = 0,
|
|
["Slot"] = (long)o.Slot
|
|
});
|
|
}
|
|
return arr.ToString(Newtonsoft.Json.Formatting.None);
|
|
}
|
|
|
|
public static string SetAvatarSaved(ulong playerid, List<avatar_data_saved> avatars)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
// Was: `player == null` only - player_Extra was dereferenced unchecked.
|
|
if (player?.player_Extra == null)
|
|
return "[]";
|
|
|
|
if (player.player_Extra.SavedOutfits == null)
|
|
player.player_Extra.SavedOutfits = new List<avatar_data_saved>();
|
|
|
|
var incomingSlots = avatars.Select(a => a.Slot).ToHashSet();
|
|
player.player_Extra.SavedOutfits.RemoveAll(a => incomingSlots.Contains(a.Slot));
|
|
|
|
player.player_Extra.SavedOutfits.AddRange(avatars);
|
|
|
|
col.Update(player);
|
|
|
|
return JsonConvert.SerializeObject(player.player_Extra.SavedOutfits);
|
|
}
|
|
|
|
public static void SetPlayerCheer(CheerCategoryEnum cheer = CheerCategoryEnum.None, ulong playerid = 0)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player_Setting1 = col.FindOne(x => x.playerid == playerid);
|
|
if (player_Setting1 != null)
|
|
{
|
|
if (player_Setting1.player.PlayerReputation != null)
|
|
{
|
|
player_Setting1.player.PlayerReputation.SelectedCheer = cheer;
|
|
col.Update(player_Setting1);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
public static CheerCategoryEnum? GetPlayerCheer(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player_Setting1 = col.FindOne(x => x.playerid == playerid);
|
|
|
|
if (player_Setting1 != null)
|
|
{
|
|
if (player_Setting1.player.PlayerReputation != null)
|
|
{
|
|
return player_Setting1.player.PlayerReputation.SelectedCheer;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public static List<ulong> GetInfluencerIds()
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var result = col.Query().Where(x => x.player_Extra.Influencer.isInfluencer == true).Select(x => x.playerid).ToList();
|
|
return result;
|
|
}
|
|
|
|
public static player_data? GetInfluencerByCreatorCode(string creatorcode)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.player_Extra.Influencer.creatorCode == creatorcode && x.player_Extra.Influencer.isInfluencer == true);
|
|
return player;
|
|
}
|
|
|
|
public static bool IsInfluencer(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
return player?.player_Extra?.Influencer?.isInfluencer == true;
|
|
}
|
|
|
|
public static void SetIsInfluencer(ulong playerid, bool IsInfluencer)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
|
|
if (player == null)
|
|
return;
|
|
|
|
if (player.player_Extra == null)
|
|
player.player_Extra = new player_extra();
|
|
|
|
if (player.player_Extra.Influencer == null)
|
|
player.player_Extra.Influencer = new Influencer();
|
|
|
|
player.player_Extra.Influencer.isInfluencer = IsInfluencer;
|
|
|
|
col.Update(player);
|
|
}
|
|
|
|
public static void SetCreatorCode(ulong playerid, string creatorcode)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
|
|
if (player == null)
|
|
return;
|
|
|
|
if (player.player_Extra == null)
|
|
player.player_Extra = new player_extra();
|
|
|
|
if (player.player_Extra.Influencer == null)
|
|
player.player_Extra.Influencer = new Influencer();
|
|
|
|
player.player_Extra.Influencer.creatorCode = creatorcode;
|
|
|
|
col.Update(player);
|
|
}
|
|
|
|
public static void SupportInfluencer(ulong requestplayerid, ulong SupportId)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == requestplayerid);
|
|
if (player != null)
|
|
{
|
|
if (player.player_Extra.Influencer == null)
|
|
{
|
|
player.player_Extra.Influencer = new Influencer();
|
|
}
|
|
|
|
player.player_Extra.Influencer.SupportingInfluencer = SupportId;
|
|
col.Update(player);
|
|
return;
|
|
}
|
|
}
|
|
|
|
public static ulong? GetMyInfluencer(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
|
|
if (player != null)
|
|
{
|
|
if (player.player_Extra.Influencer != null)
|
|
{
|
|
return player.player_Extra.Influencer.SupportingInfluencer;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// message funcs
|
|
|
|
public static List<MessageData> GetMessages(ulong playerId)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerId);
|
|
|
|
if (player == null)
|
|
return new List<MessageData>();
|
|
|
|
if (player.player_Extra.Messages == null)
|
|
player.player_Extra.Messages = new List<MessageData>();
|
|
|
|
return player.player_Extra.Messages;
|
|
}
|
|
|
|
public static MessageData? AddMessage(ulong toPlayerId, ulong fromPlayerId, WebsocketEvents.MessageType type, string? data, ulong? roomId = null, ulong? playerEventId = null)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == toPlayerId);
|
|
|
|
if (player == null)
|
|
return null;
|
|
|
|
if (player.player_Extra.Messages == null)
|
|
player.player_Extra.Messages = new List<MessageData>();
|
|
|
|
var msg = new MessageData()
|
|
{
|
|
Id = GenerateRandomMessageId(),
|
|
FromPlayerId = fromPlayerId,
|
|
SentTime = DateTime.UtcNow,
|
|
Type = type,
|
|
Data = data,
|
|
RoomId = roomId,
|
|
PlayerEventId = playerEventId
|
|
};
|
|
|
|
player.player_Extra.Messages.Add(msg);
|
|
col.Update(player);
|
|
|
|
// Nudge the recipient's open website tabs to re-fetch the inbox (cheers, coach
|
|
// messages, ...). No-op if they have no browser tab open.
|
|
Campus_live_rewrite.api.server.SiteNotifications.Notify(toPlayerId);
|
|
|
|
return msg;
|
|
}
|
|
|
|
public static void DeleteMessage(ulong playerId, ulong messageId)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerId);
|
|
|
|
if (player == null)
|
|
return;
|
|
|
|
if (player.player_Extra.Messages == null || player.player_Extra.Messages.Count == 0)
|
|
return;
|
|
|
|
var message = player.player_Extra.Messages.FirstOrDefault(m => m.Id == messageId);
|
|
|
|
if (message == null)
|
|
return;
|
|
|
|
player.player_Extra.Messages.Remove(message);
|
|
|
|
// Save changes
|
|
col.Update(player);
|
|
}
|
|
|
|
|
|
public static ulong GenerateRandomMessageId()
|
|
{
|
|
lock (randLock)
|
|
{
|
|
byte[] buffer = new byte[8];
|
|
random.NextBytes(buffer);
|
|
return BitConverter.ToUInt64(buffer, 0);
|
|
}
|
|
}
|
|
// message funcs
|
|
|
|
public static int SetCheerCredit(int cheerCredit, ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player_Setting1 = col.FindOne(x => x.playerid == playerid);
|
|
if (player_Setting1 != null)
|
|
{
|
|
if (player_Setting1.player != null)
|
|
{
|
|
player_Setting1.player.PlayerReputation.CheerCredit = cheerCredit;
|
|
col.Update(player_Setting1);
|
|
return cheerCredit;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public static void Setup()
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
col.EnsureIndex(x => x.playerid, true);
|
|
col.EnsureIndex(x => x.platform);
|
|
col.EnsureIndex(x => x.player.PlatformIds);
|
|
col.EnsureIndex(x => x.player.Username);
|
|
col.EnsureIndex(x => x.deviceId);
|
|
col.EnsureIndex(x => x.authtoken);
|
|
col.EnsureIndex(x => x.id);
|
|
col.EnsureIndex(x => x.player_Extra.Messages);
|
|
col.EnsureIndex("infl", "playerExtra.Influencer.isInfluencer");
|
|
}
|
|
|
|
public static string? GetPlayerData(ulong playerId, ulong roomId)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerId);
|
|
|
|
if (player?.player_Extra?.MyRoomData?.PlayerData == null)
|
|
return null;
|
|
|
|
var entry = player.player_Extra.MyRoomData.PlayerData.FirstOrDefault(p => p.RoomId == roomId);
|
|
|
|
return entry?.Data;
|
|
}
|
|
|
|
public static bool SetPlayerData(ulong playerId, ulong roomId, string data)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerId);
|
|
|
|
if (player == null)
|
|
return false;
|
|
|
|
if (player.player_Extra == null)
|
|
player.player_Extra = new player_extra();
|
|
|
|
if (player.player_Extra.MyRoomData == null)
|
|
player.player_Extra.MyRoomData = new MyRoomData();
|
|
|
|
if (player.player_Extra.MyRoomData.PlayerData == null)
|
|
player.player_Extra.MyRoomData.PlayerData = new List<PlayerData>();
|
|
|
|
var existingEntry = player.player_Extra.MyRoomData.PlayerData.FirstOrDefault(p => p.RoomId == roomId);
|
|
|
|
if (existingEntry != null)
|
|
{
|
|
existingEntry.Data = data;
|
|
}
|
|
else
|
|
{
|
|
player.player_Extra.MyRoomData.PlayerData.Add(new PlayerData
|
|
{
|
|
RoomId = roomId,
|
|
Data = data
|
|
});
|
|
}
|
|
|
|
return col.Update(player);
|
|
}
|
|
|
|
public static PlayerPhotoTaggingSetting GetPlayerPhotoTaggingSetting(ulong playerid)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
if (player != null)
|
|
{
|
|
if (player.player != null)
|
|
{
|
|
return player.player_Extra.PlayerPhotoTaggingSetting;
|
|
}
|
|
}
|
|
return PlayerPhotoTaggingSetting.Anyone;
|
|
}
|
|
|
|
public static bool SetPlayerPhotoTaggingSetting(ulong playerid, PlayerPhotoTaggingSetting playerPhotoTaggingSetting)
|
|
{
|
|
var col = PlayerDBFile.GetCollection<player_data>("players");
|
|
var player = col.FindOne(x => x.playerid == playerid);
|
|
if (player != null)
|
|
{
|
|
if (player.player != null)
|
|
{
|
|
player.player_Extra.PlayerPhotoTaggingSetting = playerPhotoTaggingSetting;
|
|
col.Update(player);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
}
|