Files
systemrevivalserver/Services/Admin/Pages/Server/Index.cshtml.cs
T
2025-12-26 21:48:14 -05:00

206 lines
6.7 KiB
C#

using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using DataServer.Data;
using Server.Redis;
using System.Text.Json;
namespace Server.Services.Admin.Pages.Server;
public class IndexModel : AdminPageModel
{
private readonly GameDbContext _db;
private readonly IRedisManager _redis;
private readonly ILogger<IndexModel> _logger;
private static readonly List<BroadcastRecord> _recentBroadcasts = new();
private static readonly object _lock = new();
public IndexModel(GameDbContext db, IRedisManager redis, ILogger<IndexModel> logger)
{
_db = db;
_redis = redis;
_logger = logger;
}
public int ActiveConnections { get; set; }
public int ActiveDungeons { get; set; }
public int TotalAccounts { get; set; }
public int TotalCharacters { get; set; }
public int TrackedAssets { get; set; }
public List<BroadcastRecord> RecentBroadcasts { get; set; } = new();
[TempData]
public string? Message { get; set; }
[TempData]
public bool IsError { get; set; }
public async Task OnGetAsync()
{
// Get stats from Redis
try
{
var playerCount = await _redis.Db.StringGetAsync("stats:players");
if (playerCount.HasValue && int.TryParse(playerCount, out var pc))
ActiveConnections = pc;
var dungeonCount = await _redis.Db.StringGetAsync("stats:dungeons");
if (dungeonCount.HasValue && int.TryParse(dungeonCount, out var dc))
ActiveDungeons = dc;
}
catch (Exception ex)
{
_logger.LogWarning(ex, "Failed to get stats from Redis");
}
TotalAccounts = await _db.Accounts.CountAsync();
TotalCharacters = await _db.DungeonCharacters.CountAsync(c => !c.IsDeleted);
TrackedAssets = await _db.ClientAssets.CountAsync();
lock (_lock)
{
RecentBroadcasts = _recentBroadcasts.OrderByDescending(b => b.SentAt).Take(10).ToList();
}
}
public async Task<IActionResult> OnPostBroadcastAsync(string message, string messageType)
{
if (string.IsNullOrWhiteSpace(message))
{
Message = "Message cannot be empty.";
IsError = true;
return RedirectToPage();
}
try
{
// Publish to Redis for all pods to pick up
var payload = JsonSerializer.Serialize(new
{
type = messageType ?? "system",
message = message,
duration = 10,
timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
});
await _redis.Bus.PublishAsync("server:broadcast", payload);
lock (_lock)
{
_recentBroadcasts.Add(new BroadcastRecord(message, messageType ?? "system", DateTime.UtcNow));
while (_recentBroadcasts.Count > 50)
_recentBroadcasts.RemoveAt(0);
}
Message = $"Broadcast sent ({messageType}): {message}";
_logger.LogInformation("Admin broadcast sent: [{Type}] {Message}", messageType, message);
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to send broadcast");
Message = $"Failed to send broadcast: {ex.Message}";
IsError = true;
}
return RedirectToPage();
}
public async Task<IActionResult> OnPostRefreshAssetsAsync()
{
try
{
var commandPayload = JsonSerializer.Serialize(new
{
command = "refresh_assets",
timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
});
await _redis.Bus.PublishAsync("server:command", commandPayload);
var broadcastPayload = JsonSerializer.Serialize(new
{
type = "info",
message = "Asset update available. Your client will refresh automatically.",
duration = 10,
timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
});
await _redis.Bus.PublishAsync("server:broadcast", broadcastPayload);
lock (_lock)
{
_recentBroadcasts.Add(new BroadcastRecord("Asset refresh signal sent", "system", DateTime.UtcNow));
}
Message = "Asset refresh signal sent to all pods.";
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to send asset refresh");
Message = $"Failed: {ex.Message}";
IsError = true;
}
return RedirectToPage();
}
public async Task<IActionResult> OnPostMaintenanceWarningAsync()
{
try
{
var payload = JsonSerializer.Serialize(new
{
type = "announcement",
message = "⚠️ Server maintenance in 5 minutes. Please finish your current activities.",
duration = 30,
timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
});
await _redis.Bus.PublishAsync("server:broadcast", payload);
lock (_lock)
{
_recentBroadcasts.Add(new BroadcastRecord("Maintenance warning (5 min)", "announcement", DateTime.UtcNow));
}
Message = "Maintenance warning sent to all pods.";
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to send maintenance warning");
Message = $"Failed: {ex.Message}";
IsError = true;
}
return RedirectToPage();
}
public async Task<IActionResult> OnPostServerRestartAsync()
{
try
{
var payload = JsonSerializer.Serialize(new
{
type = "alert",
message = "🔄 Server restart imminent. Please save your progress and return to hub.",
duration = 30,
timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
});
await _redis.Bus.PublishAsync("server:broadcast", payload);
lock (_lock)
{
_recentBroadcasts.Add(new BroadcastRecord("Server restart warning", "alert", DateTime.UtcNow));
}
Message = "Server restart warning sent to all pods.";
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to send restart warning");
Message = $"Failed: {ex.Message}";
IsError = true;
}
return RedirectToPage();
}
public record BroadcastRecord(string Message, string Type, DateTime SentAt);
}