niko
558 lines
29 KiB
C#
558 lines
29 KiB
C#
using Newtonsoft.Json;
|
|
using Campus_live_rewrite.api.dbs;
|
|
using Campus_live_rewrite.api.server.Classes.db_class;
|
|
using CampusLiveSource.Controllers;
|
|
using System.Net.WebSockets;
|
|
using System.Security.Principal;
|
|
using System.Text;
|
|
|
|
namespace Campus_live_rewrite.api.server
|
|
{
|
|
public static class Notifications
|
|
{
|
|
private static readonly byte[] Separator = Encoding.UTF8.GetBytes("\u001e");
|
|
|
|
// SendToPlayer/SendToPlayers are `async Task`, but 19 call sites discarded the
|
|
// returned Task (compiler warning CS4014). A websocket push that threw was then
|
|
// swallowed completely - a chat message would simply never arrive, with nothing
|
|
// in the log to say so.
|
|
//
|
|
// This preserves the exact fire-and-forget timing (awaiting would make a chat
|
|
// send wait on every recipient socket) but surfaces failures instead of hiding
|
|
// them. Behaviour is unchanged; only visibility improves.
|
|
public static void FireAndForget(Task task, string what)
|
|
{
|
|
if (task == null) return;
|
|
_ = task.ContinueWith(
|
|
t => Console.WriteLine($"[Notifications] {what} FAILED: {t.Exception?.GetBaseException().Message}"),
|
|
TaskContinuationOptions.OnlyOnFaulted);
|
|
}
|
|
|
|
public static async Task SendToPlayer(ulong playerId, string message)
|
|
{
|
|
// Any notification headed for the game also nudges the player's open website tabs to
|
|
// re-fetch their inbox, so the web bell updates the instant the game event fires.
|
|
SiteNotifications.Notify(playerId);
|
|
|
|
if (!NotificationsController.WebSockets.TryGetValue(playerId, out var socket) || socket == null)
|
|
{
|
|
Console.WriteLine($"[Notifications] No active WebSocket for player {playerId}");
|
|
return;
|
|
}
|
|
|
|
await SendAsync(socket, message, playerId);
|
|
}
|
|
|
|
// Wire names of the subscription-update frames. The client dispatches these by STRING name;
|
|
// the numeric ResponseResults values (12 / 11) were silently dropped, which is why nothing
|
|
// updated live. Confirmed against a live client by the reference (recflare notify
|
|
// notification-types.ts): "PresenceUpdate", "AccountUpdate", "SelfAccountUpdate".
|
|
public const string WirePresenceUpdate = "PresenceUpdate";
|
|
public const string WireAccountUpdate = "AccountUpdate";
|
|
public const string WireSelfAccountUpdate = "SelfAccountUpdate";
|
|
|
|
// The reduced, REDACTED presence payload (reference: presenceUpdateMessage). NOT the raw
|
|
// heartbeat: photonRoomIdYeee / voice ids must never ride along (a frame carrying them reads
|
|
// to the client as "local presence out of sync" and it walks itself home), statusVisibility
|
|
// is forced to 0 so the subject isn't hidden from a viewer allowed to see them, and
|
|
// appVersion must be a STRING or the client aborts the whole frame.
|
|
private static object PresencePayload(ulong subjectId, HeartbeatDB.Heartbeat? hb, bool forSelf = false)
|
|
{
|
|
var inst = hb?.roomInstance;
|
|
object? redacted = inst == null ? null : new
|
|
{
|
|
roomInstanceId = inst.roomInstanceId,
|
|
roomId = inst.roomId,
|
|
subRoomId = inst.subRoomId,
|
|
location = inst.location,
|
|
roomInstanceType = inst.roomInstanceType,
|
|
name = inst.name,
|
|
maxCapacity = inst.maxCapacity,
|
|
isFull = HeartbeatDB.InstanceIsFull(inst),
|
|
isPrivate = inst.isPrivate,
|
|
isInProgress = inst.isInProgress
|
|
};
|
|
return new
|
|
{
|
|
playerId = subjectId,
|
|
// Only the player themself learns their real "Appear Online To"; a viewer's copy
|
|
// says Everyone, because the setting has already been applied to what they see.
|
|
statusVisibility = forSelf ? (hb?.statusVisibility ?? 0) : 0,
|
|
deviceClass = hb?.deviceClass ?? 0,
|
|
vrMovementMode = hb?.vrMovementMode ?? 0,
|
|
roomInstance = redacted,
|
|
isOnline = hb?.isOnline ?? false,
|
|
appVersion = hb?.appVersion ?? Campus_live_rewrite.api.server.ConfigCampus.PresenceAppVersion
|
|
};
|
|
}
|
|
|
|
private static string Frame(string wireId, object payload) =>
|
|
JsonConvert.SerializeObject(new Campus_live_rewrite.api.WebsocketEvents.Reponse { Id = wireId, Msg = payload });
|
|
|
|
/// <summary>
|
|
/// Push the subject's current presence to ONE connected viewer, with that viewer's own
|
|
/// relationship and the subject's "Appear Online To" applied. Used when a viewer first
|
|
/// subscribes, so their list is live immediately.
|
|
/// </summary>
|
|
public static async Task PushPresenceTo(ulong viewerId, ulong subjectId)
|
|
{
|
|
try
|
|
{
|
|
if (!NotificationsController.WebSockets.TryGetValue(viewerId, out var socket) || socket == null) return;
|
|
var rel = FriendsDB.GetRelationships(viewerId);
|
|
bool friend = rel.Any(r => r.PlayerID == subjectId && r.RelationshipType == RelationshipType.Friend);
|
|
bool favorite = friend && rel.Any(r => r.PlayerID == subjectId && r.Favorited != ReciprocalStatus.None);
|
|
var hb = HeartbeatDB.GetPresenceForList(subjectId, viewerIsSelf: false, viewerIsFriend: friend, viewerIsFavorite: favorite, viewerId: viewerId);
|
|
await SendAsync(socket, Frame(WirePresenceUpdate, PresencePayload(subjectId, hb)), viewerId, quiet: true);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"[presence-push] {subjectId} -> {viewerId} failed: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Push the player's OWN presence to their own socket - the record with their real
|
|
/// statusVisibility and IsOnline true. The client's "you" tile / status picker reads this;
|
|
/// without it a status change only showed after the next presence poll (a minute or
|
|
/// more), and "online" never lit up for yourself on connect.
|
|
/// </summary>
|
|
public static async Task PushPresenceToSelf(ulong playerId)
|
|
{
|
|
try
|
|
{
|
|
if (!NotificationsController.WebSockets.TryGetValue(playerId, out var socket) || socket == null) return;
|
|
var hb = HeartbeatDB.GetPresenceForList(playerId, viewerIsSelf: true, viewerIsFriend: true, viewerIsFavorite: true);
|
|
await SendAsync(socket, Frame(WirePresenceUpdate, PresencePayload(playerId, hb, forSelf: true)), playerId, quiet: true);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"[presence-push] self {playerId} failed: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
// Realtime presence. Pushes a PresenceUpdate to every connected viewer that should see the
|
|
// subject - their FRIENDS plus everyone who SUBSCRIBED to them over the hub (the in-room
|
|
// player list, party members, profile cards) - whenever the subject's presence changes
|
|
// (connect, disconnect, room change, "Appear Online To"). Per-viewer, so each sees the
|
|
// subject with THEIR relationship and the subject's visibility applied. Not through
|
|
// SendToPlayer, so a presence tick never nudges anyone's website inbox.
|
|
public static async Task PushPresenceToFriends(ulong subjectId)
|
|
{
|
|
try
|
|
{
|
|
var friendIds = FriendsDB.GetRelationships(subjectId)
|
|
.Where(r => r.RelationshipType == RelationshipType.Friend)
|
|
.Select(r => r.PlayerID)
|
|
.Distinct()
|
|
.ToHashSet();
|
|
var viewers = new HashSet<ulong>(friendIds);
|
|
foreach (var v in NotificationsController.SubscribersOf(subjectId)) viewers.Add(v);
|
|
viewers.Remove(subjectId);
|
|
// The subject sees the change too, instantly - status picker, own online dot.
|
|
await PushPresenceToSelf(subjectId);
|
|
// Friends' open website tabs re-render too (online friends rail, friends modal),
|
|
// and any tab looking at this player's profile page sees the new status/room.
|
|
foreach (var fid in friendIds) SiteNotifications.Notify(fid);
|
|
SiteNotifications.ProfileChanged(subjectId);
|
|
int sent = await PushPresenceToViewers(subjectId, friendIds, viewers);
|
|
if (sent > 0) Console.WriteLine($"[presence-push] {subjectId} -> {sent} viewer(s)");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"[presence-push] subject {subjectId} failed: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
private static async Task<int> PushPresenceToViewers(ulong subjectId, HashSet<ulong> friendIds, HashSet<ulong> viewers)
|
|
{
|
|
int sent = 0;
|
|
foreach (var vid in viewers)
|
|
{
|
|
// Only currently-connected viewers get a live frame; the rest read fresh
|
|
// presence from GET /Matchmaking/player when their client next asks.
|
|
if (!NotificationsController.WebSockets.TryGetValue(vid, out var socket) || socket == null)
|
|
continue;
|
|
|
|
bool friend = friendIds.Contains(vid);
|
|
bool favorite = friend && FriendsDB.GetRelationships(vid)
|
|
.Any(r => r.PlayerID == subjectId && r.Favorited != ReciprocalStatus.None);
|
|
|
|
var hb = HeartbeatDB.GetPresenceForList(
|
|
subjectId, viewerIsSelf: false, viewerIsFriend: friend, viewerIsFavorite: favorite, viewerId: vid);
|
|
await SendAsync(socket, Frame(WirePresenceUpdate, PresencePayload(subjectId, hb)), vid, quiet: true);
|
|
sent++;
|
|
}
|
|
return sent;
|
|
}
|
|
|
|
// A presence change is sent again 3 s and 10 s later. The one push alone could be overtaken:
|
|
// after a server restart (2026-09-27) Kyle's client subscribed at 07:33:12 and was answered
|
|
// poly's stale "Dorm" row; poly landed in ^RecCenter at 07:33:14, and the friends list and
|
|
// Here Now kept showing the private dorm (Party Up and the voice slider greyed out) with poly
|
|
// standing in the room, because nothing re-sends an unchanged presence. A newer change
|
|
// cancels the older echo - it schedules its own.
|
|
private static readonly System.Collections.Concurrent.ConcurrentDictionary<ulong, long> _echoVersion = new();
|
|
private static readonly int[] EchoDelaysMs = { 3000, 7000 };
|
|
|
|
public static async Task EchoPresence(ulong subjectId)
|
|
{
|
|
long ver = _echoVersion.AddOrUpdate(subjectId, 1, (_, v) => v + 1);
|
|
foreach (int delay in EchoDelaysMs)
|
|
{
|
|
await Task.Delay(delay);
|
|
if (!_echoVersion.TryGetValue(subjectId, out var cur) || cur != ver) return;
|
|
var friendIds = FriendsDB.GetRelationships(subjectId)
|
|
.Where(r => r.RelationshipType == RelationshipType.Friend)
|
|
.Select(r => r.PlayerID)
|
|
.ToHashSet();
|
|
var viewers = new HashSet<ulong>(friendIds);
|
|
foreach (var v in NotificationsController.SubscribersOf(subjectId)) viewers.Add(v);
|
|
viewers.Remove(subjectId);
|
|
await PushPresenceToViewers(subjectId, friendIds, viewers);
|
|
}
|
|
}
|
|
|
|
// The public account projection the hub carries (reference: AccountUpdatePayload).
|
|
// PascalCase, with `createdAt` lowercase-camel - the client's canonical spelling.
|
|
private static Dictionary<string, object> AccountUpdatePayload(player_data p)
|
|
{
|
|
return new Dictionary<string, object>
|
|
{
|
|
["AccountId"] = p.playerid,
|
|
["UserName"] = p.player?.Username ?? "",
|
|
["DisplayName"] = p.player?.DisplayName ?? "",
|
|
["DisplayEmoji"] = p.player?.DisplayEmoji ?? "",
|
|
["ProfileImage"] = string.IsNullOrEmpty(p.player?.profileImage) ? "DefaultProfileImage.jpg" : p.player!.profileImage!,
|
|
// Same default /account/bulk serves. An empty BannerImage here blanked the banner
|
|
// on the Portfolio of anyone with no banner stored (563 players) the moment they
|
|
// changed their picture / bio / name - ProfileBannerImageImpl redraws from it.
|
|
["BannerImage"] = string.IsNullOrEmpty(p.player?.bannerImage) ? ConfigCampus.DefaultBannerImage : p.player!.bannerImage!,
|
|
["TreatAsJunior"] = p.player?.IsJunior ?? false,
|
|
["HasBirthday"] = true,
|
|
["PersonalPronouns"] = p.player?.pronounFlags ?? 0,
|
|
["IdentityFlags"] = p.player?.identityFlags ?? 0,
|
|
["createdAt"] = (p.player?.created_at ?? DateTime.UtcNow).ToString("o"),
|
|
["IsJunior"] = p.player?.IsJunior ?? false,
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// Push the frames that follow a profile change (reference: pushAccountUpdate). The owner
|
|
/// receives SelfAccountUpdate (owner-only fields FIRST, then the public ones - the client's
|
|
/// decoder emits a derived DTO's own members before its base's) plus AccountUpdate; everyone
|
|
/// connected receives AccountUpdate, so player cards, lists and the room's nameplates
|
|
/// re-render with the new name / picture immediately. Nulls are omitted: a null enum field
|
|
/// makes the client's parser throw. Best-effort - never fails the write that triggered it.
|
|
/// </summary>
|
|
public static async Task PushAccountUpdate(ulong accountId)
|
|
{
|
|
try
|
|
{
|
|
var p = PlayerDB.GetFullAccount(accountId);
|
|
if (p?.player == null) return;
|
|
SiteNotifications.ProfileChanged(accountId); // website tabs on this profile re-fetch it
|
|
var pub = AccountUpdatePayload(p);
|
|
|
|
var self = new Dictionary<string, object>
|
|
{
|
|
["Email"] = p.player.Email ?? "",
|
|
["Phone"] = "",
|
|
["Birthday"] = string.IsNullOrEmpty(p.player.Birthday) ? "1904-01-01T00:00:00.000Z" : p.player.Birthday!,
|
|
["JuniorState"] = p.player.IsJunior ? 1 : 0,
|
|
["AvailableUsernameChanges"] = 3,
|
|
};
|
|
foreach (var kv in pub) self[kv.Key] = kv.Value;
|
|
|
|
if (NotificationsController.WebSockets.TryGetValue(accountId, out var own) && own != null)
|
|
{
|
|
await SendAsync(own, Frame(WireSelfAccountUpdate, self), accountId, quiet: true);
|
|
await SendAsync(own, Frame(WireAccountUpdate, pub), accountId, quiet: true);
|
|
}
|
|
string frame = Frame(WireAccountUpdate, pub);
|
|
int sent = 0;
|
|
foreach (var kv in NotificationsController.WebSockets)
|
|
{
|
|
if (kv.Key == accountId || kv.Value == null) continue;
|
|
await SendAsync(kv.Value, frame, kv.Key, quiet: true);
|
|
sent++;
|
|
}
|
|
Console.WriteLine($"[account-push] {accountId} -> self + {sent} viewer(s)");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"[account-push] {accountId} failed: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
// Invoke ONE of the client's OWN hub handlers by name (RelationshipChanged,
|
|
// FriendRequestReceived, RelationshipsInvalid, GiftPackageReceived, ...) instead of the
|
|
// generic "Notification" wrapper SendToPlayer uses. The 2023 server proved against real
|
|
// client traffic that these named handlers are what actually raise a friend-request alert
|
|
// and flip the friends list live; the wrapped "Notification" path updates a message toast
|
|
// but never fires them. `type=1` = a SignalR invocation. Additive and best-effort: a client
|
|
// without the handler ignores it.
|
|
// The client has exactly ONE hub handler: the "Notification" invocation carrying a JSON
|
|
// string {Id, Msg}, dispatched by Id (reference notify/notification-types.ts). A SignalR
|
|
// invocation with any other target name is parsed and dropped in silence - which is what
|
|
// every "RelationshipsInvalid" / "RelationshipChanged" sent this way was doing. So a named
|
|
// invocation is turned into the frame the client dispatches: the relationship names map
|
|
// to their numeric ids (50 / 1), anything else rides under its own name (AccountUpdate,
|
|
// RoomUpdate, PresenceUpdate ... are name-addressed on the client).
|
|
private static readonly Dictionary<string, string> HubInvocationToFrame = new(StringComparer.OrdinalIgnoreCase)
|
|
{
|
|
["RelationshipsInvalid"] = "50",
|
|
["RelationshipChanged"] = "1",
|
|
["MessageReceived"] = "2",
|
|
["MessageDeleted"] = "3",
|
|
["RefreshLogin"] = "5",
|
|
["Logout"] = "6",
|
|
};
|
|
// Names with no client channel at all - sending them is a no-op, so they are skipped
|
|
// (the RelationshipChanged / stored-message frames beside them carry the news).
|
|
private static readonly HashSet<string> HubInvocationNoChannel = new(StringComparer.OrdinalIgnoreCase)
|
|
{
|
|
"FriendRequestReceived", "FriendRequestCancelled",
|
|
};
|
|
|
|
public static async Task SendHubInvocation(ulong playerId, string target, params object[] arguments)
|
|
{
|
|
if (HubInvocationNoChannel.Contains(target)) return;
|
|
string id = HubInvocationToFrame.TryGetValue(target, out var mapped) ? mapped : target;
|
|
object? msg = arguments != null && arguments.Length > 0 ? arguments[0] : null;
|
|
var frame = new WebsocketEvents.Reponse { Id = id, Msg = msg };
|
|
if (!NotificationsController.WebSockets.TryGetValue(playerId, out var socket) || socket == null)
|
|
return;
|
|
if (socket.State != WebSocketState.Open) return;
|
|
try
|
|
{
|
|
await SendAsync(socket, JsonConvert.SerializeObject(frame), playerId, quiet: true);
|
|
Console.WriteLine($"[Notifications] hub '{target}' (frame {id}) -> {playerId}");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"[Notifications] hub '{target}' -> {playerId} FAILED: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
// Broadcast a named hub invocation to EVERY connected client (the SendToAll twin of
|
|
// SendHubInvocation). Used for the public AccountUpdate so anyone looking at a player's
|
|
// profile redraws it live.
|
|
public static async Task SendHubInvocationToAll(string target, params object[] arguments)
|
|
{
|
|
var packet = new { type = 1, target, arguments = arguments ?? Array.Empty<object>() };
|
|
var json = JsonConvert.SerializeObject(packet);
|
|
var data = Encoding.UTF8.GetBytes(json);
|
|
var buffer = new byte[data.Length + Separator.Length];
|
|
Buffer.BlockCopy(data, 0, buffer, 0, data.Length);
|
|
Buffer.BlockCopy(Separator, 0, buffer, data.Length, Separator.Length);
|
|
|
|
var tasks = new List<Task>();
|
|
foreach (var kv in NotificationsController.WebSockets)
|
|
{
|
|
var socket = kv.Value;
|
|
if (socket == null || socket.State != WebSocketState.Open) continue;
|
|
tasks.Add(socket.SendAsync(new ArraySegment<byte>(buffer), WebSocketMessageType.Text, true, CancellationToken.None));
|
|
}
|
|
try { await Task.WhenAll(tasks); } catch (Exception ex) { Console.WriteLine($"[Notifications] hub-all '{target}' FAILED: {ex.Message}"); }
|
|
}
|
|
|
|
// The PROVEN account-update push, mirroring the reference server (RecFlare) exactly:
|
|
// 1. SelfAccountUpdate (PRIVATE self DTO) -> owner: their own account state.
|
|
// 2. AccountUpdate (PUBLIC DTO) -> owner: redraws the owner's open profile.
|
|
// 3. AccountUpdate (PUBLIC DTO) -> broadcast: everyone redraws THIS player's
|
|
// profile (new picture / banner / name) without a refetch.
|
|
// The old code sent only SelfAccountUpdate (owner) - which does NOT redraw the profile
|
|
// panel (that's why a new photo needed a relog) - and, when it once broadcast, it sent the
|
|
// PRIVATE account_data_me to everyone, which the client applied to their OWN account and
|
|
// mass-kicked them. The PUBLIC DTO (no email/settings) is what makes the broadcast safe.
|
|
// The PUBLIC account DTO as an AccountUpdate notification. `nickname` (the viewer's own name for this player) replaces the
|
|
// display name when given - nothing else about the account changes, and only that one viewer's client ever receives it.
|
|
private static string PublicAccountUpdateJson(dynamic self, string? nickname)
|
|
{
|
|
var pub = new
|
|
{
|
|
accountId = self.accountId,
|
|
username = self.username,
|
|
displayName = nickname ?? (string)self.displayName,
|
|
profileImage = self.profileImage,
|
|
bannerImage = self.bannerImage,
|
|
displayEmoji = self.displayEmoji,
|
|
isJunior = self.isJunior,
|
|
platforms = self.platforms,
|
|
personalPronouns = self.personalPronouns,
|
|
identityFlags = self.identityFlags,
|
|
createdAt = self.createdAt,
|
|
};
|
|
return JsonConvert.SerializeObject(new WebsocketEvents.Reponse { Id = "AccountUpdate", Msg = pub });
|
|
}
|
|
|
|
/// <summary>Tell ONE viewer's client to redraw a player under that viewer's nickname (or the real name once cleared) - used when
|
|
/// the nickname is set or removed on the website, so the game updates without a relog.</summary>
|
|
public static async Task PushAccountUpdateToViewer(ulong viewerId, ulong accountId)
|
|
{
|
|
var self = PlayerDB.GetAccountMeSafe(accountId);
|
|
if (self == null) return;
|
|
await SendToPlayer(viewerId, PublicAccountUpdateJson(self, SitePrefsDB.NicknameFor(viewerId, accountId)));
|
|
}
|
|
|
|
public static async Task PushAccountUpdate(ulong accountId, bool broadcast = true)
|
|
{
|
|
var self = PlayerDB.GetAccountMeSafe(accountId);
|
|
if (self == null) return;
|
|
|
|
// Deliver the SAME way the working notifications do (level/reputation/accept toast):
|
|
// wrapped by SendToPlayer/SendToAll as target="Notification" with an inner {Id, Msg},
|
|
// where the client dispatches on the inner Id. A raw named-target SignalR invocation is
|
|
// ignored by THIS (2025) client - it only reads the "Notification" envelope.
|
|
//
|
|
// ONLY AccountUpdate is sent - deliberately. It's the profile-redraw notification and
|
|
// carries the new picture/banner/name. Sending SelfAccountUpdate as WELL would make the
|
|
// client reload the SAME image id a second time concurrently and double-complete its
|
|
// load promise -> the [385120] dorm drop. One update = one load.
|
|
string pubJson = PublicAccountUpdateJson(self, null);
|
|
|
|
await SendToPlayer(accountId, pubJson); // owner: redraw their own profile
|
|
if (broadcast)
|
|
{
|
|
// everyone: redraw THIS player's profile - each viewer gets their OWN nickname for them where they set one
|
|
var tasks = new List<Task>();
|
|
foreach (var kv in NotificationsController.WebSockets)
|
|
{
|
|
string? nick = kv.Key != accountId ? SitePrefsDB.NicknameFor(kv.Key, accountId) : null;
|
|
tasks.Add(SendAsync(kv.Value, nick == null ? pubJson : PublicAccountUpdateJson(self, nick), kv.Key));
|
|
}
|
|
await Task.WhenAll(tasks);
|
|
}
|
|
}
|
|
|
|
public static async Task SendToAll(string message)
|
|
{
|
|
var tasks = NotificationsController.WebSockets
|
|
.Select(kv => SendAsync(kv.Value, message, kv.Key));
|
|
|
|
await Task.WhenAll(tasks);
|
|
}
|
|
|
|
public static async Task SendToPlayers(List<ulong> playerIds, string message)
|
|
{
|
|
var tasks = new List<Task>();
|
|
|
|
foreach (var id in playerIds)
|
|
{
|
|
if (NotificationsController.WebSockets.TryGetValue(id, out var socket) && socket != null)
|
|
tasks.Add(SendAsync(socket, message, id));
|
|
}
|
|
|
|
await Task.WhenAll(tasks);
|
|
}
|
|
|
|
private static async Task SendAsync(WebSocket socket, string message, ulong? playerId = null, bool quiet = false)
|
|
{
|
|
if (socket == null || socket.State != WebSocketState.Open)
|
|
return;
|
|
|
|
var packet = new SockSignalR
|
|
{
|
|
type = MessageTypes.Idk,
|
|
target = "Notification",
|
|
arguments = new object[] { message },
|
|
nonblocking = true,
|
|
result = "200 OK"
|
|
};
|
|
|
|
var data = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(packet));
|
|
var buffer = new byte[data.Length + Separator.Length];
|
|
Buffer.BlockCopy(data, 0, buffer, 0, data.Length);
|
|
Buffer.BlockCopy(Separator, 0, buffer, data.Length, Separator.Length);
|
|
|
|
// Log the actual message text, not the byte[] (which prints "System.Byte[]" and made
|
|
// this line useless for debugging why a push didn't land).
|
|
if (!quiet)
|
|
Console.WriteLine($"[Notifications] Sending to {(playerId.HasValue ? playerId.ToString() : "unknown player")}: {message}");
|
|
|
|
try
|
|
{
|
|
await socket.SendAsync(
|
|
new ArraySegment<byte>(buffer),
|
|
WebSocketMessageType.Text,
|
|
endOfMessage: true,
|
|
cancellationToken: CancellationToken.None
|
|
);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"[Notifications] Failed to send to {(playerId.HasValue ? playerId.ToString() : "unknown player")}: {ex.Message}");
|
|
|
|
try
|
|
{
|
|
await socket.CloseAsync(WebSocketCloseStatus.InternalServerError, "Send failed", CancellationToken.None);
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tells a player their own account changed (new profile picture, banner, identity
|
|
/// flags, ...) so their client re-reads it.
|
|
///
|
|
/// ONLY the owner is notified, and that is deliberate.
|
|
///
|
|
/// This used to ALSO push an "AccountUpdate" to every connected socket via
|
|
/// SendToAll - and the payload was GetAccountMeSafe(accountId), i.e. the changing
|
|
/// player's OWN account object (account_data_me: their id, their settings, their
|
|
/// email). Every other player in the server received one person's personal account
|
|
/// record and applied it over their own, which corrupted their client state: they
|
|
/// were error-kicked to their dorm, sometimes with the game breaking outright, and
|
|
/// sometimes bounced back into the room afterwards.
|
|
///
|
|
/// It also silently broke moderation. A banned player who got mass-kicked simply
|
|
/// rejoined the room they were in, so changing a profile picture effectively undid
|
|
/// bans for everyone online.
|
|
///
|
|
/// Other players do not need this push: the client re-reads profiles through
|
|
/// /Accounts/account/bulk when it renders them, so a new picture still appears -
|
|
/// just on next fetch instead of instantly.
|
|
///
|
|
/// If a genuine public "someone's profile changed" broadcast is ever wanted, it
|
|
/// needs its own PUBLIC payload shape (never account_data_me) - the whole problem
|
|
/// was sending a private per-player object to everyone.
|
|
/// </summary>
|
|
public static async Task<bool> RefreshAccount(ulong accountId)
|
|
{
|
|
try
|
|
{
|
|
var selfUpdate = JsonConvert.SerializeObject(
|
|
WebsocketEvents.create_player_updated_account2_Response(
|
|
"SelfAccountUpdate", PlayerDB.GetAccountMeSafe(accountId)));
|
|
|
|
await Notifications.SendToPlayer(accountId, selfUpdate);
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"Failed to send notification: {ex.Message}");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private class SockSignalR
|
|
{
|
|
public MessageTypes type { get; set; }
|
|
public string? target { get; set; }
|
|
public object[]? arguments { get; set; }
|
|
public bool nonblocking { get; set; }
|
|
public object? result { get; set; }
|
|
}
|
|
|
|
private enum MessageTypes
|
|
{
|
|
Invocation,
|
|
Idk
|
|
}
|
|
}
|
|
}
|