public virtual async Task TestPlayerPermissions() { IPermissionChecker checker = LoadChecker(); Assert.AreEqual(PermissionResult.Grant, await checker.CheckPermissionAsync(TestPlayer, "PlayerPermission.Test")); Assert.AreEqual(PermissionResult.Deny, await checker.CheckPermissionAsync(TestPlayer, "PlayerPermission.Test3")); Assert.AreEqual(PermissionResult.Default, await checker.CheckPermissionAsync(TestPlayer, "PlayerPermission.NonExistantPermission")); }
public Task <PermissionGrantResult> CheckPermissionAsync(IPermissionActor actor, string permission) { // permission is already prefixed if (permission.Contains(":")) { return(m_Parent.CheckPermissionAsync(actor, permission)); } return(m_Parent.CheckPermissionAsync(actor, m_Component.Value.OpenModComponentId + ":" + permission)); }
public virtual async Task TestAddPermissionToGroup() { IPermissionChecker checker = LoadChecker(); IPermissionProvider provider = LoadProvider(); IPermissionGroup group = await provider.GetGroupAsync("TestGroup2"); await provider.AddPermissionAsync(group, "DynamicGroupPermission"); Assert.AreEqual(PermissionResult.Grant, await checker.CheckPermissionAsync(group, "DynamicGroupPermission")); Assert.AreEqual(PermissionResult.Grant, await checker.CheckPermissionAsync(TestPlayer, "DynamicGroupPermission")); }
public virtual async Task TestRemovePermissionFromGroup() { IPermissionProvider provider = LoadProvider(); IPermissionChecker checker = LoadChecker(); IPermissionGroup group = await provider.GetGroupAsync("TestGroup2"); Assert.IsTrue(await provider.RemovePermissionAsync(group, "GroupPermission2")); Assert.AreEqual(PermissionResult.Default, await checker.CheckPermissionAsync(group, "GroupPermission2")); Assert.AreEqual(PermissionResult.Default, await checker.CheckPermissionAsync(TestPlayer, "GroupPermission2")); }
public async Task <TimeSpan?> GetLastCooldownAsync(IPlayerUser player, string kitName) { if (await m_PermissionChecker.CheckPermissionAsync(player, c_NoCooldownPermission) == PermissionGrantResult.Grant || !m_KitsCooldownData.KitsCooldown !.TryGetValue(player.Id, out var kitCooldowns)) { return(null); } var kitCooldown = kitCooldowns !.Find(x => x.KitName?.Equals(kitName, StringComparison.CurrentCultureIgnoreCase) == true); return(kitCooldown == null ? null : DateTime.Now - kitCooldown.KitCooldown); }
public virtual async Task TestChildPermissions() { IPermissionChecker checker = LoadChecker(); //should not be inherited Assert.AreEqual(PermissionResult.Default, await checker.CheckPermissionAsync(TestPlayer, "PlayerPermission.Test.ChildNode")); //should be inherited from PlayerPermission.Test2.* Assert.AreEqual(PermissionResult.Grant, await checker.CheckPermissionAsync(TestPlayer, "PlayerPermission.Test2.ChildNode")); //only has permission to the childs; not to the node itself Assert.AreEqual(PermissionResult.Default, await checker.CheckPermissionAsync(TestPlayer, "PlayerPermission.Test2")); }
public async Task <DateTime?> GetLastExecutedAsync(ICommandActor actor, string command) { if (actor.Type == KnownActorTypes.Console) { return(null); } if (await m_PermissionChecker.CheckPermissionAsync(actor, "OpenMod.Core:cooldowns.immune") == PermissionGrantResult.Grant) { return(null); } await LoadPersistedRecords(); var actorId = GetActorFullId(actor); if (m_Records.TryGetValue(actorId, out List <CooldownRecord> records)) { var record = records.FirstOrDefault(x => x.Command == command); if (record != null) { return(record.Executed); } } return(null); }
protected override async UniTask OnExecuteAsync() { if (Context.Parameters.Length > 0) { throw new CommandWrongUsageException(Context); } var warpsData = await m_DataStore.LoadAsync <WarpsData>(WarpsKey); string warps = "none"; if (warpsData.Warps.Count != 0) { StringBuilder warpsBuilder = new StringBuilder(); foreach (string warp in warpsData.Warps.Keys) { if (await m_PermissionChecker.CheckPermissionAsync(Context.Actor, $"warps.{warp}") == PermissionGrantResult.Grant) { warpsBuilder.Append(warp + ", "); } } if (warpsBuilder.Length != 0) { warpsBuilder.Remove(warpsBuilder.Length - 2, 1); warps = warpsBuilder.ToString(); } } await Context.Actor.PrintMessageAsync(m_StringLocalizer["warps:list", new { Warps = warps }]); }
public async Task ExecuteAsync(ICommandContext context) { IUser targetPlayer = await context.Parameters.GetAsync <IUser>(0); string groupName = context.Parameters[1]; string permission = "Rocket.Permissions.ManageGroups." + groupName; IPermissionProvider configPermissions = context.Container.Resolve <IPermissionProvider>("default_permissions"); IPermissionChecker permissionChecker = context.Container.Resolve <IPermissionChecker>(); if (await permissionChecker.CheckPermissionAsync(context.User, permission) != PermissionResult.Grant) { throw new NotEnoughPermissionsException(context.User, permission, "You don't have permissions to manage this group."); } IPermissionGroup groupToUpdate = await configPermissions.GetGroupAsync(groupName); if (groupToUpdate == null) { await context.User.SendMessageAsync($"Group \"{groupName}\" was not found.", Color.Red); return; } await UpdateGroupAsync(context.User, configPermissions, targetPlayer, groupToUpdate); }
public async Task <DateTime?> LastExecuted(ICommandActor actor, string command) { if (actor.Type == KnownActorTypes.Console) { return(null); } if (await m_PermissionChecker.CheckPermissionAsync(actor, $"{m_PluginAccessor.Instance.OpenModComponentId}:immune") == PermissionGrantResult.Grant) { return(null); } string actorId = GetFullId(actor); if (m_Records.TryGetValue(actorId, out List <CooldownRecord> records)) { var record = records.FirstOrDefault(x => x.Command == command); if (record != null) { return(record.Executed); } } return((await GetPersistedRecords(actorId))?.FirstOrDefault(x => x.Command == command)?.Executed); }
public bool HasPermission(IRocketPlayer player, List <string> requestedPermissions) { if (player == null) { throw new ArgumentNullException(nameof(player)); } if (requestedPermissions.Any(string.IsNullOrEmpty)) { return(true); } var actor = ConvertToActor(player); return(AsyncHelper.RunSync(async() => { foreach (var permission in requestedPermissions) { var permissionRegistration = m_PermissionRegistry.FindPermission(m_RocketModComponent, permission); if (permissionRegistration == null) { m_PermissionRegistry.RegisterPermission(m_RocketModComponent, permission); } if (await m_PermissionChecker.CheckPermissionAsync(actor, permission) == PermissionGrantResult.Grant) { return true; } } return false; })); }
public async Task <bool> DeathShouldBeLogged(UnturnedPlayerDeadEvent @event) { if (_config.allowOtherPlayer) { return(true); } return(!_config.allowOtherPlayer && _permissionChecker.CheckPermissionAsync(@event.Player.User, "back").Result == PermissionResult.Grant); }
public virtual async Task TestRemovePermissionFromPlayer() { IPermissionChecker checker = LoadChecker(); IPermissionProvider provider = LoadProvider(); Assert.IsTrue(await provider.RemovePermissionAsync(TestPlayer, "PlayerPermission.Test")); Assert.AreEqual(PermissionResult.Default, await checker.CheckPermissionAsync(TestPlayer, "PlayerPermission.Test")); }
protected override async UniTask OnExecuteAsync() { KitsData kitsData = await m_DataStore.LoadAsync <KitsData>(KitsKey); if (kitsData.Kits.Count == 0) { throw new UserFriendlyException(m_StringLocalizer["kits:none"]); } StringBuilder kitsBuilder = new StringBuilder(); if (Context.Actor.Type == KnownActorTypes.Console) { foreach (var pair in kitsData.Kits) { kitsBuilder.Append($"{pair.Key}, "); } // Remove trailing ", " kitsBuilder.Remove(kitsBuilder.Length - 2, 2); await Context.Actor.PrintMessageAsync(m_StringLocalizer["kits:list", new { List = kitsBuilder.ToString() }]); return; } foreach (var pair in kitsData.Kits) { if (await m_PermissionChecker.CheckPermissionAsync(Context.Actor, $"kits.kit.{pair.Key}") == PermissionGrantResult.Grant || await m_PermissionChecker.CheckPermissionAsync(Context.Actor, $"kits.kit.give.{pair.Key}") == PermissionGrantResult.Grant) { kitsBuilder.Append($"{pair.Key}, "); } } if (kitsBuilder.Length == 0) { throw new UserFriendlyException(m_StringLocalizer["kits:none"]); } // Remove trailing ", " kitsBuilder.Remove(kitsBuilder.Length - 2, 2); await Context.Actor.PrintMessageAsync(m_StringLocalizer["kits:list", new { List = kitsBuilder.ToString() }]); }
public async Task HandleEventAsync(object sender, IUserDisconnectedEvent @event) { UnturnedUser user = (UnturnedUser)@event.User; Jobs.Civil--; var medic = await ro_PermissionChecker.CheckPermissionAsync(user, ro_Configuration.GetSection("plugin_configuration:medic_permission").Get <string>()); var police = await ro_PermissionChecker.CheckPermissionAsync(user, ro_Configuration.GetSection("plugin_configuration:police_permission").Get <string>()); if (medic == PermissionGrantResult.Grant && !user.Player.Player.channel.owner.isAdmin && Jobs.Medic > 0) { Jobs.Medic--; } if (police == PermissionGrantResult.Grant && !user.Player.Player.channel.owner.isAdmin && Jobs.Police > 0) { Jobs.Police--; } }
public async Task GiveKitAsync(IPlayerUser user, string name, ICommandActor?instigator = null, bool forceGiveKit = false) { var kit = await m_KitStore.FindKitByNameAsync(name); if (kit == null) { throw new UserFriendlyException(m_StringLocalizer["commands:kit:notFound", new { Name = name }]); } if (!forceGiveKit && await m_PermissionChecker.CheckPermissionAsync(user, $"{KitDatabaseManager.c_KitsKey}.{kit.Name}") != PermissionGrantResult.Grant) { throw new UserFriendlyException(m_StringLocalizer["commands:kit:noPermission", new { Kit = kit }]); } var cooldown = await m_KitCooldownStore.GetLastCooldownAsync(user, name); if (!forceGiveKit && cooldown != null) { if (cooldown.Value.TotalSeconds < kit.Cooldown) { throw new UserFriendlyException(m_StringLocalizer["commands:kit:cooldown", new { Kit = kit, Cooldown = kit.Cooldown - cooldown.Value.TotalSeconds }]); } } if (!forceGiveKit && kit.Cost != 0) { await m_EconomyProvider.UpdateBalanceAsync(user.Id, user.Type, -kit.Cost, m_StringLocalizer["commands:kit:balanceUpdateReason:buy", new { Kit = kit }]); } await m_KitCooldownStore.RegisterCooldownAsync(user, name, DateTime.Now); await kit.GiveKitToPlayer(user, m_ServiceProvider); await user.PrintMessageAsync(m_StringLocalizer["commands:kit:success", new { Kit = kit }]); if (instigator != null) { await instigator.PrintMessageAsync(m_StringLocalizer["commands:kit:success", new { Kit = kit }]); } }
public async Task ExecuteAsync(ICommandContext context) { if (context.Parameters.Length != 3) { throw new CommandWrongUsageException(); } IPermissionEntity target; string permission; string permissionFailMessage; string type = context.Parameters[0].ToLower(); string targetName = context.Parameters[1]; string permissionToUpdate = context.Parameters[2]; IPermissionProvider configPermissions = context.Container.Resolve <IPermissionProvider>("default_permissions"); IPermissionChecker permissionChecker = context.Container.Resolve <IPermissionChecker>(); switch (type) { case "g": case "group": permission = "Rocket.Permissions.ManageGroups." + targetName; permissionFailMessage = "You don't have permissions to manage this group."; target = await configPermissions.GetGroupAsync(targetName); if (target == null) { await context.User.SendMessageAsync($"Group \"{targetName}\" was not found.", Color.Red); return; } break; case "p": case "player": permission = "Rocket.Permissions.ManagePlayers"; permissionFailMessage = "You don't have permissions to manage permissions of players."; target = await context.Parameters.GetAsync <IUser>(1); break; default: throw new CommandWrongUsageException(); } if (await permissionChecker.CheckPermissionAsync(context.User, permission) != PermissionResult.Grant) { throw new NotEnoughPermissionsException(context.User, permission, permissionFailMessage); } await UpdatePermissionAsync(context.User, configPermissions, target, permissionToUpdate); }
public async Task <double?> OnCooldownAsync(UserBase user, string sessionKey, string cooldownName, int cooldown) { // If there is a non-zero cooldown and the user is not exempt from cooldowns // Then we will add a cooldown to them for this specific kit/warp/etc // Unless they are already under a cooldown, in which we will return the remaining cooldown if (cooldown == 0 || await m_PermissionChecker.CheckPermissionAsync(user, $"{sessionKey}.cooldowns.exempt") != PermissionGrantResult.Deny) { return(null); } var key = $"{sessionKey}.cooldowns.{cooldownName}"; var now = DateTime.Now; var cooldowns = new Dictionary <string, DateTime>(); switch (await user.GetPersistentDataAsync <object>(CooldownsDataKey)) { case Dictionary <string, DateTime> dict: cooldowns = dict; break; case Dictionary <object, object> dict: cooldowns = dict.Select(x => new KeyValuePair <string, DateTime>(x.Key.ToString(), DateTime.Parse(x.Value.ToString()))) .ToDictionary(x => x.Key, y => y.Value); break; /*case Dictionary<string, string> dict: * cooldowns = dict.Select(x => * new KeyValuePair<string, DateTime>(x.Key, DateTime.Parse(x.Value))) * .ToDictionary(x => x.Key, y => y.Value); * break;*/ } if (cooldowns.TryGetValue(key, out var lastUse)) { var secondsSinceLastUse = (now - lastUse).TotalSeconds; if (secondsSinceLastUse < cooldown) { return(Math.Round(cooldown - secondsSinceLastUse, 2)); } cooldowns[key] = now; } else { cooldowns.Add(key, now); } await user.SavePersistentDataAsync(CooldownsDataKey, cooldowns); return(null); }
public virtual Task <PermissionGrantResult> CheckPermissionAsync(string permission) { string prefix = ""; if (!string.IsNullOrEmpty(m_CommandPermission)) { prefix = m_CommandPermission + "."; } return(m_PermissionChecker.CheckPermissionAsync(Context.Actor, prefix + permission)); }
protected override async UniTask OnExecuteAsync() { if (Context.Parameters.Length != 1) { throw new CommandWrongUsageException(Context); } var warpsData = await m_DataStore.LoadAsync <WarpsData>(WarpsKey); string searchTerm = Context.Parameters[0]; if (!warpsData.Warps.ContainsKey(searchTerm)) { throw new UserFriendlyException(m_StringLocalizer["warps:none", new { Warp = searchTerm }]); } if (await m_PermissionChecker.CheckPermissionAsync(Context.Actor, $"warps.{searchTerm}") == PermissionGrantResult.Deny) { throw new UserFriendlyException(m_StringLocalizer["warps:no_permission", new { Warp = searchTerm }]); } UnturnedUser uPlayer = (UnturnedUser)Context.Actor; var warp = warpsData.Warps[searchTerm]; double?cooldown = await m_CooldownManager.OnCooldownAsync(uPlayer, "warps", searchTerm, warp.Cooldown); if (cooldown.HasValue) { throw new UserFriendlyException(m_StringLocalizer["warps:cooldown", new { Time = cooldown, Warp = searchTerm }]); } // Delay warping so that they cannot escape combat int delay = m_Configuration.GetValue <int>("teleportation:delay"); bool cancelOnMove = m_Configuration.GetValue <bool>("teleportation:cancelOnMove"); bool cancelOnDamage = m_Configuration.GetValue <bool>("teleportation:cancelOnDamage"); // Tell the player of the delay and not to move await uPlayer.PrintMessageAsync(m_StringLocalizer["warps:success", new { Warp = searchTerm, Time = delay }]); bool success = await m_TeleportService.TeleportAsync(uPlayer, new TeleportOptions(m_PluginAccessor.Instance, delay, cancelOnMove, cancelOnDamage)); if (!success) { throw new UserFriendlyException(m_StringLocalizer["teleport:canceled"]); } await UniTask.SwitchToMainThread(); uPlayer.Player.Player.teleportToLocation(warp.Location.ToUnityVector3(), uPlayer.Player.Player.transform.eulerAngles.y); }
protected override async Task OnExecuteAsync() { var commands = await m_CommandStore.GetCommandsAsync(); var totalCount = commands.Count; const int itemsPerPage = 10; int currentPage = 1; if (Context.Parameters.Length == 0 || Context.Parameters.TryGet(0, out currentPage)) { if (currentPage < 1) { throw new CommandWrongUsageException(Context); } var pageCommands = commands .Where(d => d.ParentId == null) .Skip(itemsPerPage * (currentPage - 1)) .Take(itemsPerPage) .ToList(); await PrintPageAsync(currentPage, (int)Math.Ceiling((double)totalCount / itemsPerPage), pageCommands); } else if (Context.Parameters.Length > 0) { var context = m_CommandContextBuilder.CreateContext(Context.Actor, Context.Parameters.ToArray(), Context.CommandPrefix, commands); var permission = GetPermission(context.CommandRegistration, commands); if (context.CommandRegistration == null) { await Context.Actor.PrintMessageAsync(m_StringLocalizer["commands:errors:not_found", new { CommandName = context.GetCommandLine(false) }], Color.Red); return; } if (!string.IsNullOrEmpty(permission) && await m_PermissionChecker.CheckPermissionAsync(Context.Actor, permission) != PermissionGrantResult.Grant) { throw new NotEnoughPermissionException(m_StringLocalizer, permission); } await PrintCommandHelpAsync(context, permission, commands); await context.DisposeAsync(); } }
public bool HasPermission(IRocketPlayer player, List <string> requestedPermissions) { var actor = ConvertToActor(player); return(AsyncHelper.RunSync(async() => { foreach (var permission in requestedPermissions) { if (await m_PermissionChecker.CheckPermissionAsync(actor, permission) != PermissionGrantResult.Grant) { return false; } } return true; })); }
public virtual async Task TestGroupPermissions() { IPermissionChecker checker = LoadChecker(); IPermissionProvider provider = LoadProvider(); IPermissionGroup group = await provider.GetGroupAsync("TestGroup2"); Assert.AreEqual(PermissionResult.Default, await checker.CheckPermissionAsync(TestPlayer, "GroupPermission1")); // permission of a group the player doesnt belong to Assert.AreEqual(PermissionResult.Default, await checker.CheckPermissionAsync(TestPlayer, "NonExistantPermission")); Assert.AreEqual(PermissionResult.Grant, await checker.CheckPermissionAsync(TestPlayer, "GroupPermission2")); Assert.AreEqual(PermissionResult.Deny, await checker.CheckPermissionAsync(TestPlayer, "GroupPermission3")); Assert.AreEqual(PermissionResult.Default, await checker.CheckPermissionAsync(group, "NonExistantPermission")); Assert.AreEqual(PermissionResult.Grant, await checker.CheckPermissionAsync(group, "GroupPermission2")); Assert.AreEqual(PermissionResult.Deny, await checker.CheckPermissionAsync(group, "GroupPermission3")); }
public async Task ExecuteAsync(ICommandContext context) { IPermissionChecker permissions = context.Container.Resolve <IPermissionChecker>(); ITranslationCollection translations = ((RocketUnturnedHost)context.Container.Resolve <IHost>()).ModuleTranslations; IPlayer target; if (await permissions.CheckPermissionAsync(context.User, Permission + ".Others") == PermissionResult.Grant && context.Parameters.Length >= 1) { target = await context.Parameters.GetAsync <IPlayer>(0); } else { target = ((UnturnedUser)context.User).Player; } if (!(target is UnturnedPlayer uPlayer)) { await context.User.SendMessageAsync($"Could not heal {target.User.DisplayName}", ConsoleColor.Red); return; } uPlayer.Entity.Heal(100); uPlayer.Entity.Bleeding = false; uPlayer.Entity.Broken = false; uPlayer.Entity.Infection = 0; uPlayer.Entity.Hunger = 0; uPlayer.Entity.Thirst = 0; if (target == context.User) { await context.User.SendLocalizedMessageAsync(translations, "command_heal_success"); return; } await context.User.SendLocalizedMessageAsync(translations, "command_heal_success_me", null, target.User.DisplayName); await target.User.SendLocalizedMessageAsync(translations, "command_heal_success_other", null, context.User.DisplayName); }
/// <summary> /// Checks if the target has all of the given permissions. /// </summary> /// <param name="permissionChecker">The permission checker.</param> /// <param name="target">The target to check.</param> /// <param name="permissions">The permissions to check.</param> /// <returns> /// <see cref="PermissionResult.Grant" /> if the target explicity has access to all of the given permissions, /// <see cref="PermissionResult.Deny" /> if the target explicitly does not have access to any of the permissions; /// otherwise, <see cref="PermissionResult.Default" /> /// </returns> public static async Task <PermissionResult> CheckHasAllPermissionsAsync(this IPermissionChecker permissionChecker, IPermissionActor target, params string[] permissions) { PermissionResult result = PermissionResult.Grant; foreach (string permission in permissions) { PermissionResult tmp = await permissionChecker.CheckPermissionAsync(target, permission); if (tmp == PermissionResult.Deny) { return(PermissionResult.Deny); } if (tmp == PermissionResult.Default) { result = PermissionResult.Default; } } return(result); }
/// <summary> /// Checks if the target has any of the given permissions. /// </summary> /// <param name="permissionChecker">The permission checker.</param> /// <param name="target">The target to check.</param> /// <param name="permissions">The permissions to check.</param> /// <returns> /// <see cref="PermissionResult.Grant" /> if the target explicity has access to any of the given permissions, /// <see cref="PermissionResult.Deny" /> if the target explicitly does not have access to any of the permissions; /// otherwise, <see cref="PermissionResult.Default" /> /// </returns> public static async Task <PermissionResult> CheckHasAnyPermissionAsync(this IPermissionChecker permissionChecker, IPermissionActor target, params string[] permissions) { foreach (string permission in permissions) { Console.WriteLine("Checking: " + permission); PermissionResult result = await permissionChecker.CheckPermissionAsync(target, permission); if (result == PermissionResult.Deny) { Console.WriteLine("Denied: " + permission); return(PermissionResult.Deny); } if (result == PermissionResult.Grant) { Console.WriteLine("Granted: " + permission); return(PermissionResult.Grant); } } Console.WriteLine("Default: " + permissions); return(PermissionResult.Default); }
public async Task ExecuteAsync(ICommandContext context) { PermissionResult permResult = await _permissionChecker.CheckPermissionAsync(context.User, "back"); IUser target; bool otherUser; if (context.Parameters.Length >= 1 && _config.allowOtherPlayer) { target = await context.Parameters.GetAsync <IUser>(0); otherUser = true; } else { if (context.Parameters.Length >= 1 && !_config.allowOtherPlayer) { await context.User.SendMessageAsync("Other user functionality is disabled in the config"); return; } else { target = context.User; otherUser = false; } } if (!(target is IUser paramType)) { await context.User.SendMessageAsync("Invalid parameter"); return; } UnturnedPlayer player = ((UnturnedUser)target).Player; switch (permResult) { case PermissionResult.Grant: if (_eventHandler.deaths.ContainsKey(target)) { await player.Entity.TeleportAsync(_eventHandler.deaths[target], player.Entity.Rotation); await context.User.SendMessageAsync("You have been teleported back to your last death"); } else { if (otherUser) { await context.User.SendMessageAsync("This player hasn't died yet!"); } else { await context.User.SendMessageAsync("You haven't died yet!"); } } break; case PermissionResult.Deny: await context.User.SendMessageAsync("You do not have permission to use this command!"); //I swear there was a built in way for this? break; case PermissionResult.Default: await context.User.SendMessageAsync("You do not have permission to use this command!"); break; } }
protected override async Task OnMessageReceivedAsync(IWebSocketContext context, byte[] buffer, IWebSocketReceiveResult result) { _logger.LogDebug($"Received {buffer.Length} bytes."); _logger.LogDebug(System.Text.Encoding.UTF8.GetString(buffer)); _logger.LogDebug(string.Join(" ", buffer.Select(d => d.ToString("X")))); if (buffer.Length < 1) { return; } var type = buffer[0]; switch (type) { case PacketAuthenticate: { if (context.Items.ContainsKey("user")) { return; } var token = System.Text.Encoding.UTF8.GetString(buffer, 1, buffer.Length - 1); if (string.IsNullOrEmpty(token)) { _logger.LogDebug($"Closing socket.Invalid token: {token}."); await CloseAsync(context); return; } var user = await _authenticationService.AuthenticateAsync(token); if (user == null) { _logger.LogDebug("Closing socket. User could not authenticate."); await CloseAsync(context); return; } if (await _permissionChecker.CheckPermissionAsync(user, PermissionAccessConsole) != PermissionGrantResult.Grant) { _logger.LogDebug("Closing socket. User does not have permission."); var msg = SerializeMessage(PacketMessage, new LogMessageDto { Message = $"Missing \"OpenMod.WebServer:{PermissionAccessConsole}\" permission to access console." }); await SendAsync(context, msg); await CloseAsync(context); return; } var canReadLogs = false; // await _permissionChecker.CheckPermissionAsync(user, PermissionAccessLogs) == PermissionGrantResult.Grant; context.Items.Add("user", canReadLogs ? user : new WebConsoleUser(user, context, this)); context.Items.Add("canReadLogs", canReadLogs); _logger.LogDebug($"User accepted: {user.FullActorName} (canReadLogs: {canReadLogs})"); break; } case PacketMessage: { if (!context.Items.ContainsKey("user")) { _logger.LogDebug("Closing socket. User not authenticated."); await CloseAsync(context); return; } var user = (IUser)context.Items["user"]; var message = System.Text.Encoding.UTF8.GetString(buffer, 1, buffer.Length - 1); var args = ArgumentsParser.ParseArguments(message); await _commandExecutor.ExecuteAsync(user, args, string.Empty); break; } } }
protected override async Task OnExecuteAsync() { if (Context.Parameters.Length != 3) { throw new CommandWrongUsageException(Context); } IPermissionActor target; var actorType = Context.Parameters[0].ToLower(); var permission = "permissions.manage." + actorType; var targetName = Context.Parameters[1]; var permissionToUpdate = Context.Parameters[2]; switch (actorType) { case "r": case "role": permission = "permissions.manage.roles." + targetName; target = await m_PermissionRoleStore.GetRoleAsync(targetName); // todo: register on startup instead of here so it can get written to a help file m_PermissionRegistry.RegisterPermission(Context.CommandRegistration.Component, permission, description: $"Manage role: {targetName}"); if (target == null) { await Context.Actor.PrintMessageAsync($"Role \"{targetName}\" was not found.", Color.Red); return; } break; case "p": case "player": permission = "permissions.manage.players"; actorType = KnownActorTypes.Player; goto default; default: var idOrName = await Context.Parameters.GetAsync <string>(1); var user = await m_UserManager.FindUserAsync(actorType, idOrName, UserSearchMode.NameOrId); m_PermissionRegistry.RegisterPermission(Context.CommandRegistration.Component, permission, description: $"Manage actor: {actorType}"); if (user == null) { // todo: make localizable throw new UserFriendlyException($"Player not found: {idOrName}"); } var userData = await m_UserDataStore.GetUserDataAsync(user.Id, actorType); target = (UserDataPermissionActor)userData; break; } // we call m_PermissionChecker from here so the permission will become OpenMod.Core.manage.players instead of if (await m_PermissionChecker.CheckPermissionAsync(Context.Actor, permission) != PermissionGrantResult.Grant) { throw new NotEnoughPermissionException(Context, permission); } await ExecuteUpdateAsync(target, permissionToUpdate); }
private async UniTask CheckAfkPlayers() { if (Provider.isServer) { await SyncPlayers(); } while (m_ServiceRunning) { await UniTask.SwitchToThreadPool(); await UniTask.Delay(10000); var timeout = m_Configuration.GetSection("afkchecker:timeout").Get <int>(); var announce = m_Configuration.GetSection("afkchecker:announceAFK").Get <bool>(); var kick = m_Configuration.GetSection("afkchecker:kickAFK").Get <bool>(); if (timeout < 0 || (!kick && !announce)) { continue; } foreach (var user in m_UnturnedUserDirectory.GetOnlineUsers().ToList()) { if (!user.Session.SessionData.TryGetValue("lastMovement", out object @time) || @time is not TimeSpan span) { continue; } bool afk = (DateTime.Now.TimeOfDay - span).TotalSeconds >= timeout && await m_PermissionChecker.CheckPermissionAsync(user, "afkchecker.exempt") != PermissionGrantResult.Grant; if (!afk) { user.Session.SessionData["isAfk"] = false; continue; } if (!user.Session.SessionData.TryGetValue("isAfk", out var unparsedAfk) || unparsedAfk is not bool isAfk) { continue; } // todo: add announceTime and kickTime (not just timeout) if (announce && !isAfk) { await user.Provider?.BroadcastAsync(m_StringLocalizer["afk:announcement", new { Player = user.DisplayName }], Color.White); } if (kick) { await user.Session?.DisconnectAsync(m_StringLocalizer["afk:kicked"]); continue; } user.Session.SessionData["isAfk"] = true; } } }