dfc8ea6aee
* Stuff * Fix RoundStatus Action * Rename stuff * Also needs to run on the main thread * minor stuff * Move to not be an EntitySystem * Part 1 of making this less shit * Make some more stuff run on main thread * Actor check, logging and remove token from log. * Better log * Change ActionKick to use Guid instead of username * Fix build * Bandaid fix for test fails
796 lines
28 KiB
C#
796 lines
28 KiB
C#
using System.Net;
|
|
using System.Net.Http;
|
|
using System.Text.Json;
|
|
using System.Text.Json.Nodes;
|
|
using System.Threading.Tasks;
|
|
using Content.Server.Administration.Systems;
|
|
using Content.Server.GameTicking;
|
|
using Content.Server.GameTicking.Presets;
|
|
using Content.Server.GameTicking.Rules.Components;
|
|
using Content.Server.Maps;
|
|
using Content.Server.RoundEnd;
|
|
using Content.Shared.Administration.Managers;
|
|
using Content.Shared.CCVar;
|
|
using Content.Shared.Prototypes;
|
|
using Robust.Server.ServerStatus;
|
|
using Robust.Shared.Asynchronous;
|
|
using Robust.Shared.Configuration;
|
|
using Robust.Shared.Network;
|
|
using Robust.Shared.Player;
|
|
using Robust.Shared.Prototypes;
|
|
using Robust.Shared.Utility;
|
|
|
|
namespace Content.Server.Administration;
|
|
|
|
public sealed class ServerApi : IPostInjectInit
|
|
{
|
|
[Dependency] private readonly IStatusHost _statusHost = default!;
|
|
[Dependency] private readonly IConfigurationManager _config = default!;
|
|
[Dependency] private readonly ISharedPlayerManager _playerManager = default!; // Players
|
|
[Dependency] private readonly ISharedAdminManager _adminManager = default!; // Admins
|
|
[Dependency] private readonly IGameMapManager _gameMapManager = default!; // Map name
|
|
[Dependency] private readonly IServerNetManager _netManager = default!; // Kick
|
|
[Dependency] private readonly IPrototypeManager _prototypeManager = default!; // Game rules
|
|
[Dependency] private readonly IComponentFactory _componentFactory = default!; // Needed to circumvent the "IoC has no context on this thread" error until I figure out how to do it properly
|
|
[Dependency] private readonly ITaskManager _taskManager = default!; // game explodes when calling stuff from the non-game thread
|
|
[Dependency] private readonly EntityManager _entityManager = default!;
|
|
|
|
[Dependency] private readonly IEntitySystemManager _entitySystemManager = default!;
|
|
|
|
private string _token = default!;
|
|
private ISawmill _sawmill = default!;
|
|
private string _motd = default!;
|
|
|
|
public void PostInject()
|
|
{
|
|
_sawmill = Logger.GetSawmill("serverApi");
|
|
|
|
// Get
|
|
_statusHost.AddHandler(InfoHandler);
|
|
_statusHost.AddHandler(GetGameRules);
|
|
_statusHost.AddHandler(GetForcePresets);
|
|
|
|
// Post
|
|
_statusHost.AddHandler(ActionRoundStatus);
|
|
_statusHost.AddHandler(ActionKick);
|
|
_statusHost.AddHandler(ActionAddGameRule);
|
|
_statusHost.AddHandler(ActionEndGameRule);
|
|
_statusHost.AddHandler(ActionForcePreset);
|
|
_statusHost.AddHandler(ActionForceMotd);
|
|
_statusHost.AddHandler(ActionPanicPunker);
|
|
|
|
// Bandaid fix for the test fails
|
|
// "System.Collections.Generic.KeyNotFoundException : The given key 'server.admin_api_token' was not present in the dictionary."
|
|
// TODO: Figure out why this happens
|
|
try
|
|
{
|
|
_config.OnValueChanged(CCVars.AdminApiToken, UpdateToken, true);
|
|
_config.OnValueChanged(CCVars.MOTD, UpdateMotd, true);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
_sawmill.Error("Failed to subscribe to config vars: {0}", e);
|
|
}
|
|
|
|
}
|
|
|
|
public void Shutdown()
|
|
{
|
|
_config.UnsubValueChanged(CCVars.AdminApiToken, UpdateToken);
|
|
_config.UnsubValueChanged(CCVars.MOTD, UpdateMotd);
|
|
}
|
|
|
|
private void UpdateToken(string token)
|
|
{
|
|
_token = token;
|
|
}
|
|
|
|
private void UpdateMotd(string motd)
|
|
{
|
|
_motd = motd;
|
|
}
|
|
|
|
|
|
#region Actions
|
|
|
|
/// <summary>
|
|
/// Changes the panic bunker settings.
|
|
/// </summary>
|
|
private async Task<bool> ActionPanicPunker(IStatusHandlerContext context)
|
|
{
|
|
if (context.RequestMethod != HttpMethod.Post || context.Url!.AbsolutePath != "/admin/actions/panic_bunker")
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!CheckAccess(context))
|
|
{
|
|
await context.RespondErrorAsync(HttpStatusCode.Unauthorized);
|
|
return true;
|
|
}
|
|
|
|
if (!CheckActor(context, out var actor))
|
|
{
|
|
await context.RespondAsync("An actor is required to perform this action.", HttpStatusCode.BadRequest);
|
|
return true;
|
|
}
|
|
|
|
var actionSupplied = context.RequestHeaders.TryGetValue("Action", out var action);
|
|
if (!actionSupplied)
|
|
{
|
|
await context.RespondErrorAsync(HttpStatusCode.BadRequest);
|
|
return true;
|
|
}
|
|
|
|
var valueSupplied = context.RequestHeaders.TryGetValue("Value", out var value);
|
|
if (!valueSupplied)
|
|
{
|
|
await context.RespondErrorAsync(HttpStatusCode.BadRequest);
|
|
return true;
|
|
}
|
|
|
|
switch (action) // TODO: This looks bad, there has to be a better way to do this.
|
|
{
|
|
case "enabled":
|
|
if (!bool.TryParse(value.ToString(), out var enabled))
|
|
{
|
|
await context.RespondErrorAsync(HttpStatusCode.BadRequest);
|
|
return true;
|
|
}
|
|
|
|
_taskManager.RunOnMainThread(() =>
|
|
{
|
|
_config.SetCVar(CCVars.PanicBunkerEnabled, enabled);
|
|
});
|
|
break;
|
|
case "disable_with_admins":
|
|
if (!bool.TryParse(value.ToString(), out var disableWithAdmins))
|
|
{
|
|
await context.RespondErrorAsync(HttpStatusCode.BadRequest);
|
|
return true;
|
|
}
|
|
|
|
_taskManager.RunOnMainThread(() =>
|
|
{
|
|
_config.SetCVar(CCVars.PanicBunkerDisableWithAdmins, disableWithAdmins);
|
|
});
|
|
break;
|
|
case "enable_without_admins":
|
|
if (!bool.TryParse(value.ToString(), out var enableWithoutAdmins))
|
|
{
|
|
await context.RespondErrorAsync(HttpStatusCode.BadRequest);
|
|
return true;
|
|
}
|
|
|
|
_taskManager.RunOnMainThread(() =>
|
|
{
|
|
_config.SetCVar(CCVars.PanicBunkerEnableWithoutAdmins, enableWithoutAdmins);
|
|
});
|
|
break;
|
|
case "count_deadminned_admins":
|
|
if (!bool.TryParse(value.ToString(), out var countDeadminnedAdmins))
|
|
{
|
|
await context.RespondErrorAsync(HttpStatusCode.BadRequest);
|
|
return true;
|
|
}
|
|
|
|
_taskManager.RunOnMainThread(() =>
|
|
{
|
|
_config.SetCVar(CCVars.PanicBunkerCountDeadminnedAdmins, countDeadminnedAdmins);
|
|
});
|
|
break;
|
|
case "show_reason":
|
|
if (!bool.TryParse(value.ToString(), out var showReason))
|
|
{
|
|
await context.RespondErrorAsync(HttpStatusCode.BadRequest);
|
|
return true;
|
|
}
|
|
|
|
_taskManager.RunOnMainThread(() =>
|
|
{
|
|
_config.SetCVar(CCVars.PanicBunkerShowReason, showReason);
|
|
});
|
|
break;
|
|
case "min_account_age_hours":
|
|
if (!int.TryParse(value.ToString(), out var minAccountAgeHours))
|
|
{
|
|
await context.RespondErrorAsync(HttpStatusCode.BadRequest);
|
|
return true;
|
|
}
|
|
|
|
_taskManager.RunOnMainThread(() =>
|
|
{
|
|
_config.SetCVar(CCVars.PanicBunkerMinAccountAge, minAccountAgeHours * 60);
|
|
});
|
|
break;
|
|
case "min_overall_hours":
|
|
if (!int.TryParse(value.ToString(), out var minOverallHours))
|
|
{
|
|
await context.RespondErrorAsync(HttpStatusCode.BadRequest);
|
|
return true;
|
|
}
|
|
|
|
_taskManager.RunOnMainThread(() =>
|
|
{
|
|
_config.SetCVar(CCVars.PanicBunkerMinOverallHours, minOverallHours * 60);
|
|
});
|
|
break;
|
|
}
|
|
|
|
_sawmill.Info($"Panic bunker setting {action} changed to {value} by {actor!.Name}({actor!.Guid}).");
|
|
await context.RespondAsync("Success", HttpStatusCode.OK);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the current MOTD.
|
|
/// </summary>
|
|
private async Task<bool> ActionForceMotd(IStatusHandlerContext context)
|
|
{
|
|
if (context.RequestMethod != HttpMethod.Post || context.Url!.AbsolutePath != "/admin/actions/set_motd")
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!CheckAccess(context))
|
|
{
|
|
await context.RespondErrorAsync(HttpStatusCode.Unauthorized);
|
|
return true;
|
|
}
|
|
|
|
if (!CheckActor(context, out var actor))
|
|
{
|
|
await context.RespondAsync("An actor is required to perform this action.", HttpStatusCode.BadRequest);
|
|
return true;
|
|
}
|
|
|
|
var motdSupplied = context.RequestHeaders.TryGetValue("MOTD", out var motd);
|
|
if (!motdSupplied)
|
|
{
|
|
await context.RespondErrorAsync(HttpStatusCode.BadRequest);
|
|
return true;
|
|
}
|
|
|
|
_sawmill.Info($"MOTD changed to \"{motd}\" by {actor!.Name}({actor!.Guid}).");
|
|
|
|
_taskManager.RunOnMainThread(() => _config.SetCVar(CCVars.MOTD, motd.ToString()));
|
|
// A hook in the MOTD system sends the changes to each client
|
|
await context.RespondAsync("Success", HttpStatusCode.OK);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Forces the next preset-
|
|
/// </summary>
|
|
private async Task<bool> ActionForcePreset(IStatusHandlerContext context)
|
|
{
|
|
if (context.RequestMethod != HttpMethod.Post || context.Url!.AbsolutePath != "/admin/actions/force_preset")
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!CheckAccess(context))
|
|
{
|
|
await context.RespondErrorAsync(HttpStatusCode.Unauthorized);
|
|
return true;
|
|
}
|
|
|
|
if (!CheckActor(context, out var actor))
|
|
{
|
|
await context.RespondAsync("An actor is required to perform this action.", HttpStatusCode.BadRequest);
|
|
return true;
|
|
}
|
|
|
|
var ticker = _entitySystemManager.GetEntitySystem<GameTicker>();
|
|
|
|
if (ticker.RunLevel != GameRunLevel.PreRoundLobby)
|
|
{
|
|
_sawmill.Info($"Attempted to force preset {actor!.Name}({actor!.Guid}) while the game was not in the pre-round lobby.");
|
|
await context.RespondAsync("This can only be executed while the game is in the pre-round lobby.", HttpStatusCode.BadRequest);
|
|
return true;
|
|
}
|
|
|
|
var presetSupplied = context.RequestHeaders.TryGetValue("PresetId", out var preset);
|
|
if (!presetSupplied)
|
|
{
|
|
await context.RespondErrorAsync(HttpStatusCode.BadRequest);
|
|
return true;
|
|
}
|
|
|
|
var result = await RunOnMainThread(() => ticker.FindGamePreset(preset.ToString()));
|
|
if (result == null)
|
|
{
|
|
await context.RespondAsync($"No preset exists with name {preset}.", HttpStatusCode.NotFound);
|
|
return true;
|
|
}
|
|
|
|
_taskManager.RunOnMainThread(() =>
|
|
{
|
|
ticker.SetGamePreset(result);
|
|
});
|
|
_sawmill.Info($"Forced the game to start with preset {preset} by {actor!.Name}({actor!.Guid}).");
|
|
await context.RespondAsync("Success", HttpStatusCode.OK);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ends an active game rule.
|
|
/// </summary>
|
|
private async Task<bool> ActionEndGameRule(IStatusHandlerContext context)
|
|
{
|
|
if (context.RequestMethod != HttpMethod.Post || context.Url!.AbsolutePath != "/admin/actions/end_game_rule")
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!CheckAccess(context))
|
|
{
|
|
await context.RespondErrorAsync(HttpStatusCode.Unauthorized);
|
|
return true;
|
|
}
|
|
|
|
if (!CheckActor(context, out var actor))
|
|
{
|
|
await context.RespondAsync("An actor is required to perform this action.", HttpStatusCode.BadRequest);
|
|
return true;
|
|
}
|
|
|
|
var gameRuleSupplied = context.RequestHeaders.TryGetValue("GameRuleId", out var gameRule);
|
|
if (!gameRuleSupplied)
|
|
{
|
|
_sawmill.Info($"Attempted to end game rule without supplying a game rule name by {actor!.Name}({actor!.Guid}).");
|
|
await context.RespondErrorAsync(HttpStatusCode.BadRequest);
|
|
return true;
|
|
}
|
|
var ticker = _entitySystemManager.GetEntitySystem<GameTicker>();
|
|
var gameRuleEntity = await RunOnMainThread(() => ticker
|
|
.GetActiveGameRules()
|
|
.FirstOrNull(rule => _entityManager.MetaQuery.GetComponent(rule).EntityPrototype?.ID == gameRule.ToString()));
|
|
|
|
if (gameRuleEntity == null) // Game rule not found
|
|
{
|
|
_sawmill.Info($"Attempted to end game rule {gameRule} by {actor!.Name}({actor!.Guid}), but it was not found.");
|
|
await context.RespondAsync("Gamerule not found or not active",HttpStatusCode.NotFound);
|
|
return true;
|
|
}
|
|
|
|
_sawmill.Info($"Ended game rule {gameRule} by {actor!.Name}({actor!.Guid}).");
|
|
_taskManager.RunOnMainThread(() => ticker.EndGameRule((EntityUid) gameRuleEntity));
|
|
await context.RespondAsync($"Ended game rule {gameRule}({gameRuleEntity})", HttpStatusCode.OK);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a game rule to the current round.
|
|
/// </summary>
|
|
private async Task<bool> ActionAddGameRule(IStatusHandlerContext context)
|
|
{
|
|
if (context.RequestMethod != HttpMethod.Post || context.Url!.AbsolutePath != "/admin/actions/add_game_rule")
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!CheckAccess(context))
|
|
{
|
|
await context.RespondErrorAsync(HttpStatusCode.Unauthorized);
|
|
return true;
|
|
}
|
|
|
|
if (!CheckActor(context, out var actor))
|
|
{
|
|
await context.RespondAsync("An actor is required to perform this action.", HttpStatusCode.BadRequest);
|
|
return true;
|
|
}
|
|
|
|
var gameRuleSupplied = context.RequestHeaders.TryGetValue("GameRuleId", out var gameRule);
|
|
if (!gameRuleSupplied)
|
|
{
|
|
_sawmill.Info($"Attempted to add game rule without supplying a game rule name by {actor!.Name}({actor!.Guid}).");
|
|
await context.RespondErrorAsync(HttpStatusCode.BadRequest);
|
|
return true;
|
|
}
|
|
|
|
var ticker = _entitySystemManager.GetEntitySystem<GameTicker>();
|
|
|
|
var tsc = new TaskCompletionSource<EntityUid>();
|
|
_taskManager.RunOnMainThread(() =>
|
|
{
|
|
var ruleEntity = ticker.AddGameRule(gameRule.ToString());
|
|
_sawmill.Info($"Added game rule {gameRule} by {actor!.Name}({actor!.Guid}).");
|
|
if (ticker.RunLevel == GameRunLevel.InRound)
|
|
{
|
|
ticker.StartGameRule(ruleEntity);
|
|
_sawmill.Info($"Started game rule {gameRule} by {actor!.Name}({actor!.Guid}).");
|
|
}
|
|
tsc.TrySetResult(ruleEntity);
|
|
});
|
|
|
|
var ruleEntity = await tsc.Task;
|
|
await context.RespondAsync($"Added game rule {ruleEntity}", HttpStatusCode.OK);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Kicks a player.
|
|
/// </summary>
|
|
private async Task<bool> ActionKick(IStatusHandlerContext context)
|
|
{
|
|
if (context.RequestMethod != HttpMethod.Post || context.Url!.AbsolutePath != "/admin/actions/kick")
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!CheckAccess(context))
|
|
{
|
|
await context.RespondErrorAsync(HttpStatusCode.Unauthorized);
|
|
return true;
|
|
}
|
|
|
|
if (!CheckActor(context, out var actor))
|
|
{
|
|
await context.RespondAsync("An actor is required to perform this action.", HttpStatusCode.BadRequest);
|
|
return true;
|
|
}
|
|
|
|
var playerSupplied = context.RequestHeaders.TryGetValue("Guid", out var guid);
|
|
if (!playerSupplied)
|
|
{
|
|
_sawmill.Info($"Attempted to kick player without supplying a username by {actor!.Name}({actor!.Guid}).");
|
|
await context.RespondErrorAsync(HttpStatusCode.BadRequest);
|
|
return true;
|
|
}
|
|
|
|
var session = await RunOnMainThread(() =>
|
|
{
|
|
// There is no function to get a session by GUID, so we have to iterate over all sessions and check their GUIDs.
|
|
foreach (var player in _playerManager.Sessions)
|
|
{
|
|
if (player.UserId.UserId.ToString() == guid.ToString())
|
|
{
|
|
return player;
|
|
}
|
|
}
|
|
return null;
|
|
});
|
|
|
|
if (session == null)
|
|
{
|
|
_sawmill.Info($"Attempted to kick player {guid} by {actor!.Name}({actor!.Guid}), but they were not found.");
|
|
await context.RespondAsync("Player not found", HttpStatusCode.NotFound);
|
|
return true;
|
|
}
|
|
|
|
var reasonSupplied = context.RequestHeaders.TryGetValue("Reason", out var reason);
|
|
if (!reasonSupplied)
|
|
{
|
|
reason = "No reason supplied";
|
|
}
|
|
|
|
reason += " (kicked by admin)";
|
|
|
|
_taskManager.RunOnMainThread(() =>
|
|
{
|
|
_netManager.DisconnectChannel(session.Channel, reason.ToString());
|
|
});
|
|
await context.RespondAsync("Success", HttpStatusCode.OK);
|
|
_sawmill.Info("Kicked player {0} ({1}) for {2} by {3}({4})", session.Name, session.UserId.UserId.ToString(), reason, actor!.Name, actor!.Guid);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Round restart/end
|
|
/// </summary>
|
|
private async Task<bool> ActionRoundStatus(IStatusHandlerContext context)
|
|
{
|
|
if (context.RequestMethod != HttpMethod.Post || context.Url!.AbsolutePath != "/admin/actions/round")
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!CheckAccess(context))
|
|
{
|
|
await context.RespondErrorAsync(HttpStatusCode.Unauthorized);
|
|
return true;
|
|
}
|
|
|
|
if (!CheckActor(context, out var actor))
|
|
{
|
|
await context.RespondAsync("An actor is required to perform this action.", HttpStatusCode.BadRequest);
|
|
return true;
|
|
}
|
|
|
|
// Not using body, because that's a stream and I don't want to deal with that
|
|
var actionSupplied = context.RequestHeaders.TryGetValue("Action", out var action);
|
|
if (!actionSupplied)
|
|
{
|
|
_sawmill.Info($"Attempted to {action} round without supplying an action by {actor!.Name}({actor!.Guid}).");
|
|
await context.RespondErrorAsync(HttpStatusCode.BadRequest);
|
|
return true;
|
|
}
|
|
|
|
var ticker = _entitySystemManager.GetEntitySystem<GameTicker>();
|
|
var roundEndSystem = _entitySystemManager.GetEntitySystem<RoundEndSystem>();
|
|
switch (action)
|
|
{
|
|
case "start":
|
|
if (ticker.RunLevel != GameRunLevel.PreRoundLobby)
|
|
{
|
|
await context.RespondAsync("Round already started", HttpStatusCode.BadRequest);
|
|
_sawmill.Info("Forced round start failed: round already started");
|
|
return true;
|
|
}
|
|
_taskManager.RunOnMainThread(() =>
|
|
{
|
|
ticker.StartRound();
|
|
});
|
|
_sawmill.Info("Forced round start");
|
|
break;
|
|
case "end":
|
|
if (ticker.RunLevel != GameRunLevel.InRound)
|
|
{
|
|
await context.RespondAsync("Round already ended", HttpStatusCode.BadRequest);
|
|
_sawmill.Info("Forced round end failed: round is not in progress");
|
|
return true;
|
|
}
|
|
_taskManager.RunOnMainThread(() =>
|
|
{
|
|
roundEndSystem.EndRound();
|
|
});
|
|
_sawmill.Info("Forced round end");
|
|
break;
|
|
case "restart":
|
|
if (ticker.RunLevel != GameRunLevel.InRound)
|
|
{
|
|
await context.RespondAsync("Round already ended", HttpStatusCode.BadRequest);
|
|
_sawmill.Info("Forced round restart failed: round is not in progress");
|
|
return true;
|
|
}
|
|
_taskManager.RunOnMainThread(() =>
|
|
{
|
|
roundEndSystem.EndRound();
|
|
});
|
|
_sawmill.Info("Forced round restart");
|
|
break;
|
|
case "restartnow": // You should restart yourself NOW!!!
|
|
_taskManager.RunOnMainThread(() =>
|
|
{
|
|
ticker.RestartRound();
|
|
});
|
|
_sawmill.Info("Forced instant round restart");
|
|
break;
|
|
default:
|
|
await context.RespondErrorAsync(HttpStatusCode.BadRequest);
|
|
return true;
|
|
}
|
|
|
|
_sawmill.Info($"Round {action} by {actor!.Name}({actor!.Guid}).");
|
|
await context.RespondAsync("Success", HttpStatusCode.OK);
|
|
return true;
|
|
}
|
|
#endregion
|
|
|
|
#region Fetching
|
|
|
|
/// <summary>
|
|
/// Returns an array containing all presets.
|
|
/// </summary>
|
|
private async Task<bool> GetForcePresets(IStatusHandlerContext context)
|
|
{
|
|
if (context.RequestMethod != HttpMethod.Get || context.Url!.AbsolutePath != "/admin/force_presets")
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!CheckAccess(context))
|
|
{
|
|
await context.RespondErrorAsync(HttpStatusCode.Unauthorized);
|
|
return true;
|
|
}
|
|
|
|
var jObject = new JsonObject();
|
|
var presets = new List<string>();
|
|
foreach (var preset in _prototypeManager.EnumeratePrototypes<GamePresetPrototype>())
|
|
{
|
|
presets.Add(preset.ID);
|
|
}
|
|
|
|
jObject["presets"] = JsonNode.Parse(JsonSerializer.Serialize(presets));
|
|
await context.RespondAsync(jObject.ToString(), HttpStatusCode.OK);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns an array containing all game rules.
|
|
/// </summary>
|
|
private async Task<bool> GetGameRules(IStatusHandlerContext context)
|
|
{
|
|
if (context.RequestMethod != HttpMethod.Get || context.Url!.AbsolutePath != "/admin/game_rules")
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!CheckAccess(context))
|
|
{
|
|
await context.RespondErrorAsync(HttpStatusCode.Unauthorized);
|
|
return true;
|
|
}
|
|
|
|
var jObject = new JsonObject();
|
|
var gameRules = new List<string>();
|
|
foreach (var gameRule in _prototypeManager.EnumeratePrototypes<EntityPrototype>())
|
|
{
|
|
if (gameRule.Abstract)
|
|
continue;
|
|
|
|
if (gameRule.HasComponent<GameRuleComponent>(_componentFactory))
|
|
gameRules.Add(gameRule.ID);
|
|
}
|
|
|
|
jObject["game_rules"] = JsonNode.Parse(JsonSerializer.Serialize(gameRules));
|
|
await context.RespondAsync(jObject.ToString(), HttpStatusCode.OK);
|
|
return true;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Handles fetching information.
|
|
/// </summary>
|
|
private async Task<bool> InfoHandler(IStatusHandlerContext context)
|
|
{
|
|
if (context.RequestMethod != HttpMethod.Get || context.Url!.AbsolutePath != "/admin/info" || _token == string.Empty)
|
|
{
|
|
return false;
|
|
// 404
|
|
}
|
|
|
|
if (!CheckAccess(context))
|
|
{
|
|
await context.RespondErrorAsync(HttpStatusCode.Unauthorized);
|
|
return true;
|
|
}
|
|
|
|
if (!CheckActor(context, out var actor))
|
|
{
|
|
await context.RespondAsync("An actor is required to perform this action.", HttpStatusCode.BadRequest);
|
|
return true;
|
|
}
|
|
|
|
/* Information to display
|
|
Round number
|
|
Connected players
|
|
Active admins
|
|
Active game rules
|
|
Active game preset
|
|
Active map
|
|
MOTD
|
|
Panic bunker status
|
|
*/
|
|
|
|
var ticker = _entitySystemManager.GetEntitySystem<GameTicker>();
|
|
var adminSystem = _entitySystemManager.GetEntitySystem<AdminSystem>();
|
|
|
|
var jObject = new JsonObject();
|
|
|
|
jObject["round_id"] = await RunOnMainThread(() => ticker.RoundId);
|
|
|
|
var players = new List<Player>();
|
|
var onlineAdmins = new List<Player>();
|
|
var onlineAdminsDeadmined = new List<Player>();
|
|
|
|
foreach (var player in _playerManager.Sessions)
|
|
{
|
|
players.Add(new Player
|
|
{
|
|
Guid = player.UserId.UserId.ToString(),
|
|
Name = player.Name
|
|
});
|
|
if (await RunOnMainThread(() => _adminManager.IsAdmin(player)))
|
|
{
|
|
onlineAdmins.Add(new Player
|
|
{
|
|
Guid = player.UserId.UserId.ToString(),
|
|
Name = player.Name
|
|
});
|
|
}
|
|
else if (await RunOnMainThread(() => _adminManager.IsAdmin(player, true)))
|
|
{
|
|
onlineAdminsDeadmined.Add(new Player
|
|
{
|
|
Guid = player.UserId.UserId.ToString(),
|
|
Name = player.Name
|
|
});
|
|
}
|
|
}
|
|
|
|
// The JsonSerializer.Serialize into JsonNode.Parse is a bit of a hack
|
|
jObject["players"] = JsonNode.Parse(JsonSerializer.Serialize(players));
|
|
jObject["admins"] = JsonNode.Parse(JsonSerializer.Serialize(onlineAdmins));
|
|
jObject["deadmined"] = JsonNode.Parse(JsonSerializer.Serialize(onlineAdminsDeadmined));
|
|
|
|
var gameRules = new List<string>();
|
|
foreach (var addedGameRule in await RunOnMainThread(() => ticker.GetActiveGameRules()))
|
|
{
|
|
var meta = _entityManager.MetaQuery.GetComponent(addedGameRule);
|
|
gameRules.Add(meta.EntityPrototype?.ID ?? meta.EntityPrototype?.Name ?? "Unknown");
|
|
}
|
|
|
|
jObject["game_rules"] = JsonNode.Parse(JsonSerializer.Serialize(gameRules));
|
|
jObject["game_preset"] = ticker.CurrentPreset?.ID;
|
|
jObject["map"] = await RunOnMainThread(() => _gameMapManager.GetSelectedMap()?.MapName ?? "Unknown");
|
|
jObject["motd"] = _motd;
|
|
jObject["panic_bunker"] = new JsonObject();
|
|
jObject["panic_bunker"]!["enabled"] = adminSystem.PanicBunker.Enabled;
|
|
jObject["panic_bunker"]!["disable_with_admins"] = adminSystem.PanicBunker.DisableWithAdmins;
|
|
jObject["panic_bunker"]!["enable_without_admins"] = adminSystem.PanicBunker.EnableWithoutAdmins;
|
|
jObject["panic_bunker"]!["count_deadminned_admins"] = adminSystem.PanicBunker.CountDeadminnedAdmins;
|
|
jObject["panic_bunker"]!["show_reason"] = adminSystem.PanicBunker.ShowReason;
|
|
jObject["panic_bunker"]!["min_account_age_hours"] = adminSystem.PanicBunker.MinAccountAgeHours;
|
|
jObject["panic_bunker"]!["min_overall_hours"] = adminSystem.PanicBunker.MinOverallHours;
|
|
|
|
_sawmill.Info($"Info requested by {actor!.Name}({actor!.Guid}).");
|
|
await context.RespondAsync(jObject.ToString(), HttpStatusCode.OK);
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
private bool CheckAccess(IStatusHandlerContext context)
|
|
{
|
|
var auth = context.RequestHeaders.TryGetValue("Authorization", out var authToken);
|
|
if (!auth)
|
|
{
|
|
_sawmill.Info(@"Unauthorized access attempt to admin API. No auth header");
|
|
return false;
|
|
} // No auth header, no access
|
|
|
|
if (authToken == _token)
|
|
return true;
|
|
|
|
// Invalid auth header, no access
|
|
_sawmill.Info(@"Unauthorized access attempt to admin API. ""{0}""", authToken.ToString());
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Async helper function which runs a task on the main thread and returns the result.
|
|
/// </summary>
|
|
private async Task<T> RunOnMainThread<T>(Func<T> func)
|
|
{
|
|
var taskCompletionSource = new TaskCompletionSource<T>();
|
|
_taskManager.RunOnMainThread(() =>
|
|
{
|
|
taskCompletionSource.TrySetResult(func());
|
|
});
|
|
|
|
var result = await taskCompletionSource.Task;
|
|
return result;
|
|
}
|
|
|
|
private bool CheckActor(IStatusHandlerContext context, out Player? actor)
|
|
{
|
|
// We are trusting the header to be correct.
|
|
// This is fine because the header is set by the SS14.Admin backend.
|
|
var actorSupplied = context.RequestHeaders.TryGetValue("Actor", out var actorHeader);
|
|
if (!actorSupplied)
|
|
{
|
|
actor = null;
|
|
return false;
|
|
}
|
|
|
|
var stringRep = actorHeader.ToString();
|
|
actor = new Player()
|
|
{
|
|
// GUID_NAME format
|
|
Guid = stringRep[..stringRep.IndexOf('_')],
|
|
Name = stringRep[(stringRep.IndexOf('_') + 1)..]
|
|
};
|
|
return true;
|
|
}
|
|
|
|
private sealed class Player
|
|
{
|
|
public string Guid { get; set; } = default!;
|
|
public string Name { get; set; } = default!;
|
|
}
|
|
}
|