public static bool IsRainbowTagUser(this ReferenceHub hub)
{
string group = ServerStatic.GetPermissionsHandler().GetUserGroup(hub.characterClassManager.UserId)
.GetGroupName();
return(!string.IsNullOrEmpty(group) && RainbowTagMod.ActiveRoles.Contains(group));
}
public static bool IsRainbowTagUser(this Player hub)
{
string group = ServerStatic.GetPermissionsHandler().GetUserGroup(hub.UserId)
.GetGroupName();
return(!string.IsNullOrEmpty(group) && RainbowTagMod.RainbowTagRef.Config.ActiveGroups.Contains(group));
}
/// <summary>
/// Sets the rank of a <see cref="ReferenceHub">player</see> by giving a <paramref name="name"/>, <paramref name="color"/>, and setting if it should be shown with <paramref name="show"/>, as well as the <paramref name="rankName"/>, the server should use for permissions.
/// </summary>
public static void SetRank(this ReferenceHub player, string name, string color, bool show, string rankName)
{
// Developer note: I bet I just needed to use the show once. But hey, better be safe than sorry.
if (ServerStatic.GetPermissionsHandler()._groups.ContainsKey(rankName))
{
ServerStatic.GetPermissionsHandler()._groups[rankName].BadgeColor = color;
ServerStatic.GetPermissionsHandler()._groups[rankName].BadgeText = name;
ServerStatic.GetPermissionsHandler()._groups[rankName].HiddenByDefault = !show;
ServerStatic.GetPermissionsHandler()._groups[rankName].Cover = show;
player.serverRoles.SetGroup(ServerStatic.GetPermissionsHandler()._groups[rankName], false, false, show);
}
else
{
UserGroup ug = new UserGroup()
{
BadgeColor = color,
BadgeText = name,
HiddenByDefault = !show,
Cover = show
};
ServerStatic.GetPermissionsHandler()._groups.Add(rankName, ug);
player.serverRoles.SetGroup(ug, false, false, show);
}
if (ServerStatic.GetPermissionsHandler()._members.ContainsKey(player.GetUserId()))
{
ServerStatic.GetPermissionsHandler()._members[player.GetUserId()] = rankName;
}
else
{
ServerStatic.GetPermissionsHandler()._members.Add(player.GetUserId(), rankName);
}
}
private void handler(AdminQueryEvent ev, string perm, bool hierarchy = false)
{
ServerRoles serverRoles = ((UnityEngine.GameObject)ev.Admin.GetGameObject()).GetComponent <ServerRoles>();
PermissionsHandler permissionsHandler = ServerStatic.GetPermissionsHandler();
if ((permissionsHandler.StaffAccess && serverRoles.Staff) || (permissionsHandler.ManagersAccess && serverRoles.RaEverywhere) || (permissionsHandler.BanningTeamAccess && serverRoles.RaEverywhere))
{
return;
}
Server server = PluginManager.Manager.Server;
if (hierarchy && plugin.GetConfigBool("AP_HIERARCHY_ENABLE"))
{
bool isHigher = true;
string[] queryArgs = ev.Query.Split(' ');
if (queryArgs.Length > 1)
{
List <Player> playerList = server.GetPlayers("");
string[] players = queryArgs[1].Split('.');
playerList = playerList.FindAll(p => {
if (Array.IndexOf(players, p.PlayerId.ToString()) > -1)
{
return(true);
}
return(false);
});
if (playerList.Count > 0)
{
foreach (Player player in playerList)
{
if (!checkHierarchy(ev.Admin, player))
{
isHigher = false;
}
}
}
}
if (!isHigher)
{
ev.Successful = false;
ev.Handled = true;
ev.Output = "Player is higher rank than you!";
}
}
if (!hasPerm(ev.Admin, ev.Admin.GetUserGroup().Name, perm))
{
ev.Successful = false;
ev.Handled = true;
ev.Output = "You Don't Have Permission to do that! You require the permission " + perm + "!";
}
}
/// <summary>
/// Reloads RemoteAdmin configs.
/// </summary>
public static void ReloadRemoteAdmin()
{
ServerStatic.RolesConfig = new YamlConfig(ServerStatic.RolesConfigPath);
ServerStatic.SharedGroupsConfig = (GameCore.ConfigSharing.Paths[4] == null) ? null : new YamlConfig(GameCore.ConfigSharing.Paths[4] + "shared_groups.txt");
ServerStatic.SharedGroupsMembersConfig = (GameCore.ConfigSharing.Paths[5] == null) ? null : new YamlConfig(GameCore.ConfigSharing.Paths[5] + "shared_groups_members.txt");
ServerStatic.PermissionsHandler = new PermissionsHandler(ref ServerStatic.RolesConfig, ref ServerStatic.SharedGroupsConfig, ref ServerStatic.SharedGroupsMembersConfig);
ServerStatic.GetPermissionsHandler().RefreshPermissions();
}
// Remind me to include it into Exiled
private string GetGroupKey(UserGroup group)
{
if (group == null)
{
return(string.Empty);
}
return(ServerStatic.GetPermissionsHandler()._groups.FirstOrDefault(g => EqualsTo(g.Value, group)).Key ??
string.Empty);
}
/// <summary>
/// Reloads RemoteAdmin configs.
/// </summary>
public static void ReloadRemoteAdmin()
{
ServerStatic.RolesConfig = new YamlConfig(ServerStatic.RolesConfigPath);
ServerStatic.SharedGroupsConfig = (GameCore.ConfigSharing.Paths[4] == null) ? null : new YamlConfig(GameCore.ConfigSharing.Paths[4] + "shared_groups.txt");
ServerStatic.SharedGroupsMembersConfig = (GameCore.ConfigSharing.Paths[5] == null) ? null : new YamlConfig(GameCore.ConfigSharing.Paths[5] + "shared_groups_members.txt");
ServerStatic.PermissionsHandler = new PermissionsHandler(ref ServerStatic.RolesConfig, ref ServerStatic.SharedGroupsConfig, ref ServerStatic.SharedGroupsMembersConfig);
ServerStatic.GetPermissionsHandler().RefreshPermissions();
foreach (Player p in Player.List)
{
p.ReferenceHub.serverRoles.SetGroup(null, false, false, false);
p.ReferenceHub.serverRoles.RefreshPermissions();
}
}
public static void Prefix(DissonanceUserSetup __instance, bool value)
{
Exiled.API.Features.Player player = Exiled.API.Features.Player.Get(__instance.gameObject);
if (string.IsNullOrEmpty(player?.UserId) || player.Team != Team.SCP)
{
return;
}
else if (ScpUtils.StaticInstance.Config.AllowedScps.Contains(player.Role))
{
__instance.MimicAs939 = value; return;
}
else if (string.IsNullOrEmpty(ServerStatic.GetPermissionsHandler()._groups.FirstOrDefault(g => g.Value == player.ReferenceHub.serverRoles.Group).Key) && !string.IsNullOrEmpty(player.ReferenceHub.serverRoles.MyText))
{
return;
}
else if (player.CheckPermission($"scputils_speak.{player.Role.ToString().ToLower()}"))
{
__instance.MimicAs939 = value;
}
}
public void playerJoin(PlayerJoinEvent ev)
{
ReferenceHub player = ev.Player;
String steamID = ev.Player.characterClassManager.UserId;
string role;
if (Plugin.role.TryGetValue(steamID, out role))
{
if (ServerStatic.GetPermissionsHandler()._groups.ContainsKey(role))
{
EXILED.Extensions.Player.SetRank(player, ServerStatic.GetPermissionsHandler()._groups[role].BadgeText, ServerStatic.GetPermissionsHandler()._groups[role].BadgeColor, true, role);
}
else
{
Log.Error("Le role \"" + role + "\" n'existe pas dans la configuration (Utilisateur: " + player.nicknameSync.MyNick + ").");
}
Plugin.role.Remove(steamID);
}
}
public static bool Prefix(NetworkConnection conn, Scp939VoiceMessage msg)
{
Exiled.API.Features.Player player = Exiled.API.Features.Player.Get(conn.identity.netId);
if (string.IsNullOrEmpty(player?.UserId) || player.Team != Team.SCP)
{
return(false);
}
else if (ScpUtils.StaticInstance.Config.AllowedScps.Contains(player.Role))
{
return(player.ReferenceHub.dissonanceUserSetup.MimicAs939 = msg.IsMimicking);
}
else if (string.IsNullOrEmpty(ServerStatic.GetPermissionsHandler()._groups.FirstOrDefault(g => g.Value == player.ReferenceHub.serverRoles.Group).Key) && !string.IsNullOrEmpty(player.ReferenceHub.serverRoles.MyText))
{
return(false);
}
else if (player.CheckPermission($"scputils_speak.{player.Role.ToString().ToLower()}"))
{
return(player.ReferenceHub.dissonanceUserSetup.MimicAs939 = msg.IsMimicking);
}
else
{
return(false);
}
}
public static bool CheckPermission(ReferenceHub player, string permission)
{
if (player == null)
{
Log.Error("Reference hub was null, unable to check permissions.");
return(false);
}
Log.Debug($"Player: {player.GetNickname()} UserID: {player.GetUserId()}");
if (string.IsNullOrEmpty(permission))
{
Log.Error("Permission checked was null.");
return(false);
}
Log.Debug($"Permission string: {permission}");
UserGroup userGroup = ServerStatic.GetPermissionsHandler().GetUserGroup(player.GetUserId());
Group group = null;
if (userGroup != null)
{
Log.Debug($"UserGroup: {userGroup.BadgeText}");
string groupName = ServerStatic.GetPermissionsHandler()._groups.FirstOrDefault(g => g.Value == player.serverRoles.Group).Key;
Log.Debug($"GroupName: {groupName}");
if (permissionsconfig == null)
{
Log.Error("Permissions config is null.");
return(false);
}
if (!permissionsconfig.groups.Any())
{
Log.Error("No permissionconfig groups.");
return(false);
}
if (!permissionsconfig.groups.TryGetValue(groupName, out group))
{
Log.Error("Could not get permission value.");
return(false);
}
Log.Debug($"Got group.");
}
else
{
Log.Debug("user group is null, getting default..");
group = GetDefaultGroup();
}
if (group != null)
{
Log.Debug("Group is not null!");
if (permission.Contains("."))
{
Log.Debug("Group contains perm seperator");
if (group.permissions.Any(s => s == ".*"))
{
Log.Debug("All perms granted for all nodes.");
return(true);
}
if (group.permissions.Contains(permission.Split('.')[0] + ".*"))
{
Log.Debug("Check 1: True, returning.");
return(true);
}
}
if (group.permissions.Contains(permission) || group.permissions.Contains("*"))
{
Log.Debug("Check 2: True, returning.");
return(true);
}
}
else
{
Log.Debug("Group is null, returning false.");
return(false);
}
Log.Debug("No permissions found.");
return(false);
}
/// <summary>
/// Checks a player's permission.
/// </summary>
/// <param name="player">The player to be checked.</param>
/// <param name="permission">The permission to be checked.</param>
/// <returns>true if the player's current or native group has permissions; otherwise, false.</returns>
public static bool CheckPermission(this Player player, string permission)
{
if (string.IsNullOrEmpty(permission))
{
return(false);
}
if (Server.Host == player)
{
return(true);
}
if (player == null || player.GameObject == null || Groups == null || Groups.Count == 0)
{
return(false);
}
Log.Debug($"UserID: {player.UserId} | PlayerId: {player.Id}", Instance.Config.ShouldDebugBeShown);
Log.Debug($"Permission string: {permission}", Instance.Config.ShouldDebugBeShown);
string plyGroupKey = player.Group != null?ServerStatic.GetPermissionsHandler()._groups.FirstOrDefault(g => g.Value.EqualsTo(player.Group)).Key : null;
Log.Debug($"GroupKey: {plyGroupKey ?? "(null)"}", Instance.Config.ShouldDebugBeShown);
if (plyGroupKey == null || !Groups.TryGetValue(plyGroupKey, out Group group))
{
Log.Debug("The source group is null, the default group is used", Instance.Config.ShouldDebugBeShown);
group = DefaultGroup;
}
if (group == null)
{
Log.Debug("There's no default group, returning false...", Instance.Config.ShouldDebugBeShown);
return(false);
}
const char permSeparator = '.';
const string allPerms = ".*";
if (group.CombinedPermissions.Contains(allPerms))
{
return(true);
}
if (permission.Contains(permSeparator))
{
StringBuilder strBuilder = StringBuilderPool.Shared.Rent();
string[] seraratedPermissions = permission.Split(permSeparator);
bool Check(string source) => group.CombinedPermissions.Contains(source, StringComparison.OrdinalIgnoreCase);
bool result = false;
for (int z = 0; z < seraratedPermissions.Length; z++)
{
if (z != 0)
{
// We need to clear the last ALL_PERMS line
// or it'll be like 'permission.*.subpermission'.
strBuilder.Length -= allPerms.Length;
// Separate permission groups by using its separator.
strBuilder.Append(permSeparator);
}
strBuilder.Append(seraratedPermissions[z]);
// If it's the last index,
// then we don't need to check for all permissions of the subpermission.
if (z == seraratedPermissions.Length - 1)
{
result = Check(strBuilder.ToString());
break;
}
strBuilder.Append(allPerms);
if (Check(strBuilder.ToString()))
{
result = true;
break;
}
}
StringBuilderPool.Shared.Return(strBuilder);
Log.Debug($"Result in the block: {result}", Instance.Config.ShouldDebugBeShown);
return(result);
}
// It'll work when there is no dot in the permission.
bool result2 = group.CombinedPermissions.Contains(permission, StringComparison.OrdinalIgnoreCase);
Log.Debug($"Result outside the block: {result2}", Instance.Config.ShouldDebugBeShown);
return(result2);
}
public static string GetGroupName(this UserGroup group) => ServerStatic.GetPermissionsHandler().GetAllGroups().Where(p => p.Value == group).Select(p => p.Key) .FirstOrDefault();
private static void HandleConnection(ConnectionRequest request)
{
NetDataWriter rejectData = new NetDataWriter();
try
{
byte result1;
byte result2;
int position = request.Data.Position;
if (!request.Data.TryGetByte(out result1) || !request.Data.TryGetByte(out result2) || result1 != CustomNetworkManager.Major || result2 != CustomNetworkManager.Minor)
{
rejectData.Reset();
rejectData.Put(3);
request.Reject(rejectData);
}
else
{
if (CustomLiteNetLib4MirrorTransport.IpRateLimiting)
{
if (CustomLiteNetLib4MirrorTransport.IpRateLimit.Contains(request.RemoteEndPoint.Address.ToString()))
{
ServerConsole.AddLog(string.Format("Incoming connection from endpoint {0} rejected due to exceeding the rate limit.", request.RemoteEndPoint));
ServerLogs.AddLog(ServerLogs.Modules.Networking, string.Format("Incoming connection from endpoint {0} rejected due to exceeding the rate limit.", request.RemoteEndPoint), ServerLogs.ServerLogType.RateLimit);
rejectData.Reset();
rejectData.Put(12);
request.Reject(rejectData);
return;
}
CustomLiteNetLib4MirrorTransport.IpRateLimit.Add(request.RemoteEndPoint.Address.ToString());
}
if (!CharacterClassManager.OnlineMode)
{
KeyValuePair <BanDetails, BanDetails> keyValuePair = BanHandler.QueryBan(null, request.RemoteEndPoint.Address.ToString());
if (keyValuePair.Value != null)
{
ServerConsole.AddLog(string.Format("Player tried to connect from banned endpoint {0}.", request.RemoteEndPoint));
rejectData.Reset();
rejectData.Put(6);
rejectData.Put(keyValuePair.Value.Expires);
rejectData.Put(keyValuePair.Value?.Reason ?? string.Empty);
request.Reject(rejectData);
}
else
{
request.Accept();
}
}
else
{
string result3;
if (!request.Data.TryGetString(out result3) || result3 == string.Empty)
{
rejectData.Reset();
rejectData.Put(5);
request.Reject(rejectData);
}
else
{
ulong result4;
byte result5;
string result6;
byte[] result7;
if (!request.Data.TryGetULong(out result4) || !request.Data.TryGetByte(out result5) || !request.Data.TryGetString(out result6) || !request.Data.TryGetBytesWithLength(out result7))
{
rejectData.Reset();
rejectData.Put(4);
request.Reject(rejectData);
}
else
{
CentralAuthPreauthFlags flags = (CentralAuthPreauthFlags)result5;
try
{
if (!ECDSA.VerifyBytes(string.Format("{0};{1};{2};{3}", result3, result5, result6, result4), result7, ServerConsole.PublicKey))
{
ServerConsole.AddLog(string.Format("Player from endpoint {0} sent preauthentication token with invalid digital signature.", request.RemoteEndPoint));
rejectData.Reset();
rejectData.Put(2);
request.Reject(rejectData);
}
else if (TimeBehaviour.CurrentUnixTimestamp > result4)
{
ServerConsole.AddLog(string.Format("Player from endpoint {0} sent expired preauthentication token.", request.RemoteEndPoint));
ServerConsole.AddLog("Make sure that time and timezone set on server is correct. We recommend synchronizing the time.");
rejectData.Reset();
rejectData.Put(11);
request.Reject(rejectData);
}
else
{
if (CustomLiteNetLib4MirrorTransport.UserRateLimiting)
{
if (CustomLiteNetLib4MirrorTransport.UserRateLimit.Contains(result3))
{
ServerConsole.AddLog(string.Format("Incoming connection from {0} ({1}) rejected due to exceeding the rate limit.", result3, request.RemoteEndPoint));
ServerLogs.AddLog(ServerLogs.Modules.Networking, string.Format("Incoming connection from endpoint {0} ({1}) rejected due to exceeding the rate limit.", result3, request.RemoteEndPoint), ServerLogs.ServerLogType.RateLimit);
rejectData.Reset();
rejectData.Put(12);
request.Reject(rejectData);
return;
}
CustomLiteNetLib4MirrorTransport.UserRateLimit.Add(result3);
}
if (!flags.HasFlagFast(CentralAuthPreauthFlags.IgnoreBans) || !ServerStatic.GetPermissionsHandler().IsVerified)
{
KeyValuePair <BanDetails, BanDetails> keyValuePair = BanHandler.QueryBan(result3, request.RemoteEndPoint.Address.ToString());
if (keyValuePair.Key != null || keyValuePair.Value != null)
{
ServerConsole.AddLog(string.Format("{0} {1} tried to connect from {2} endpoint {3}.", keyValuePair.Key == null ? "Player" : "Banned player", result3, keyValuePair.Value == null ? "" : "banned ", request.RemoteEndPoint));
ServerLogs.AddLog(ServerLogs.Modules.Networking, string.Format("{0} {1} tried to connect from {2} endpoint {3}.", keyValuePair.Key == null ? "Player" : "Banned player", result3, keyValuePair.Value == null ? "" : "banned ", request.RemoteEndPoint), ServerLogs.ServerLogType.ConnectionUpdate);
rejectData.Reset();
rejectData.Put(6);
NetDataWriter netDataWriter1 = rejectData;
BanDetails key = keyValuePair.Key;
netDataWriter1.Put(key != null ? key.Expires : keyValuePair.Value.Expires);
NetDataWriter netDataWriter2 = rejectData;
string str;
if ((str = keyValuePair.Key?.Reason) == null)
{
str = keyValuePair.Value?.Reason ?? string.Empty;
}
netDataWriter2.Put(str);
request.Reject(rejectData);
return;
}
}
if (flags.HasFlagFast(CentralAuthPreauthFlags.GloballyBanned) && !ServerStatic.GetPermissionsHandler().IsVerified)
{
bool useGlobalBans = CustomLiteNetLib4MirrorTransport.UseGlobalBans;
}
if ((!flags.HasFlagFast(CentralAuthPreauthFlags.IgnoreWhitelist) || !ServerStatic.GetPermissionsHandler().IsVerified) && !WhiteList.IsWhitelisted(result3))
{
ServerConsole.AddLog(string.Format("Player {0} tried joined from endpoint {1}, but is not whitelisted.", result3, request.RemoteEndPoint));
rejectData.Reset();
rejectData.Put(7);
request.Reject(rejectData);
}
else if (CustomLiteNetLib4MirrorTransport.Geoblocking != GeoblockingMode.None && (!flags.HasFlagFast(CentralAuthPreauthFlags.IgnoreGeoblock) || !ServerStatic.GetPermissionsHandler().BanTeamBypassGeo) && (!CustomLiteNetLib4MirrorTransport.GeoblockIgnoreWhitelisted || !WhiteList.IsOnWhitelist(result3)) && (CustomLiteNetLib4MirrorTransport.Geoblocking == GeoblockingMode.Whitelist && !CustomLiteNetLib4MirrorTransport.GeoblockingList.Contains(result6.ToUpper()) || CustomLiteNetLib4MirrorTransport.Geoblocking == GeoblockingMode.Blacklist && CustomLiteNetLib4MirrorTransport.GeoblockingList.Contains(result6.ToUpper())))
{
ServerConsole.AddLog(string.Format("Player {0} ({1}) tried joined from blocked country {2}.", result3, request.RemoteEndPoint, result6.ToUpper()));
rejectData.Reset();
rejectData.Put(9);
request.Reject(rejectData);
}
else
{
int num = CustomNetworkManager.slots;
if (flags.HasFlagFast(CentralAuthPreauthFlags.ReservedSlot) && ServerStatic.GetPermissionsHandler().BanTeamSlots)
{
num = LiteNetLib4MirrorNetworkManager.singleton.maxConnections;
}
else if (ConfigFile.ServerConfig.GetBool("use_reserved_slots", true) && ReservedSlot.HasReservedSlot(result3))
{
num += CustomNetworkManager.reservedSlots;
}
if (LiteNetLib4MirrorCore.Host.PeersCount < num)
{
if (CustomLiteNetLib4MirrorTransport.UserIds.ContainsKey(request.RemoteEndPoint))
{
CustomLiteNetLib4MirrorTransport.UserIds[request.RemoteEndPoint].SetUserId(result3);
}
else
{
CustomLiteNetLib4MirrorTransport.UserIds.Add(request.RemoteEndPoint, new PreauthItem(result3));
}
bool allow = true;
Events.InvokePreAuth(result3, request, position, result5, result6, ref allow);
if (allow)
{
request.Accept();
ServerConsole.AddLog(string.Format("Player {0} preauthenticated from endpoint {1}.", result3, request.RemoteEndPoint));
ServerLogs.AddLog(ServerLogs.Modules.Networking, string.Format("{0} preauthenticated from endpoint {1}.", result3, request.RemoteEndPoint), ServerLogs.ServerLogType.ConnectionUpdate);
}
else
{
ServerConsole.AddLog(string.Format("Player {0} tried to preauthenticate from endpoint {1}, but the request has been rejected by a plugin.", result3, request.RemoteEndPoint));
ServerLogs.AddLog(ServerLogs.Modules.Networking, string.Format("{0} tried to preauthenticate from endpoint {1}, but the request has been rejected by a plugin.", result3, request.RemoteEndPoint), ServerLogs.ServerLogType.ConnectionUpdate);
}
}
else
{
rejectData.Reset();
rejectData.Put(1);
request.Reject(rejectData);
}
}
}
}
catch (Exception exception)
{
ServerConsole.AddLog(string.Format("Player from endpoint {0} sent an invalid preauthentication token. {1}", request.RemoteEndPoint, exception.Message));
rejectData.Reset();
rejectData.Put(2);
request.Reject(rejectData);
}
}
}
}
}
}
catch (Exception exception)
{
ServerConsole.AddLog(string.Format("Player from endpoint {0} failed to preauthenticate: {1}", request.RemoteEndPoint, exception.Message));
rejectData.Reset();
rejectData.Put(4);
request.Reject(rejectData);
}
}
internal static bool CheckPermission(Player player, string permission)
{
if (player == null)
{
Log.Error("The player has not been found, therefor no permission check could be done!");
return(false);
}
if (string.IsNullOrEmpty(permission))
{
Log.Error("Permission checked was null.");
return(false);
}
var userGroup = ServerStatic.GetPermissionsHandler().GetUserGroup(player.UserId);
Group group = null;
if (userGroup != null)
{
var groupName = ServerStatic.GetPermissionsHandler()._groups
.FirstOrDefault(g => g.Value == player.Rank).Key;
if (_permissionsConfig == null)
{
Log.Error("Permission config is null.");
return(false);
}
if (!_permissionsConfig.Groups.Any())
{
Log.Error("No permission group.");
return(false);
}
if (!_permissionsConfig.Groups.TryGetValue(groupName, out group))
{
Log.Info($"TheServerGroup: {groupName} has no Permission Group!");
if (player.Hub.serverRoles.Staff || player.UserId.EndsWith("@northwood"))
{
group = GetNwGroup();
}
else
{
group = GetDefaultGroup();
}
}
}
else
{
if (player.Hub.serverRoles.Staff || player.UserId.EndsWith("@northwood"))
{
group = GetNwGroup();
}
else
{
group = GetDefaultGroup();
}
}
if (group != null)
{
if (permission.Contains("."))
{
if (group.Permissions.Any(s => s == ".*"))
{
return(true);
}
}
if (group.Permissions.Contains(permission.Split('.')[0] + ".*"))
{
return(true);
}
if (group.Permissions.Contains(permission) || group.Permissions.Contains("*"))
{
return(true);
}
}
else
{
return(false);
}
return(false);
}
internal static bool TriggerCommand(CommandInfo cInfo)
{
if (!allCommands.ContainsKey(cInfo.commandName))
{
return(false);
}
MethodInfo cmd = allCommands[cInfo.commandName];
if (cmd == null || cmd.Equals(default(Type)))
{
return(false);
}
UserGroup uGroup = ServerStatic.GetPermissionsHandler().GetUserGroup(cInfo.gameObject.GetComponent <RemoteAdmin.QueryProcessor>().PlayerId.ToString());
PMOverrideRanks overrideRanks = (PMOverrideRanks)cmd.GetCustomAttribute(typeof(PMOverrideRanks));
if (overrideRanks == null || !overrideRanks.ranks.Contains(uGroup.ToString()))
{
PMPermission perm = (PMPermission)cmd.GetCustomAttribute(typeof(PMPermission));
if (perm != null && !perm.CheckPermissions(cInfo.commandSender, perm.perm))
{
cInfo.commandSender.RaReply(cInfo.commandName + "#You don't have permission to execute this command.\nMissing permission: " + perm.perm, false, true, "");
return(true);
}
PMPermissions perms = (PMPermissions)cmd.GetCustomAttribute(typeof(PMPermissions));
if (perms != null)
{
PlayerPermissions[] permList = perms.CheckPermissions(cInfo.commandSender, perms.perms).ToArray();
if (permList != null)
{
if (perms.type == RequirementType.Single)
{
cInfo.commandSender.RaReply(cInfo.commandName + $"#You don't have permission to execute this command.\nYou must have one of the following: {string.Join(", ", permList)}", false, true, "");
}
else if (perms.type == RequirementType.All)
{
cInfo.commandSender.RaReply(cInfo.commandName + $"#You must have one of the following permmissions to run this command.\nMissing permissions: {string.Join(", ", permList)}", false, true, "");
}
return(true);
}
}
PMRankWhitelist whitelist = (PMRankWhitelist)cmd.GetCustomAttribute(typeof(PMRankWhitelist));
if (whitelist != null && !whitelist.ranks.Contains(uGroup.ToString()))
{
cInfo.commandSender.RaReply(cInfo.commandName + "#You are not whitelisted to run this command.", false, true, "");
return(true);
}
PMRankBlacklist blacklist = (PMRankBlacklist)cmd.GetCustomAttribute(typeof(PMRankBlacklist));
if (blacklist != null && blacklist.ranks.Contains(uGroup.ToString()))
{
cInfo.commandSender.RaReply(cInfo.commandName + "#You are not whitelisted to run this command.", false, true, "");
return(true);
}
}
PMParameters parameters = (PMParameters)cmd.GetCustomAttribute(typeof(PMParameters));
PMCanExtend pmCanExtend = (PMCanExtend)cmd.GetCustomAttribute(typeof(PMCanExtend));
bool canExtend = (pmCanExtend != null ? pmCanExtend.canExtend : false);
if (parameters == null)
{
throw new Exception($"PMParameters is null for command: {cInfo.commandName}");
}
if (cInfo.commandArgs.Length - 1 < parameters.parameters.Length)
{
cInfo.commandSender.RaReply(cInfo.commandName + $"#{cInfo.commandName.ToUpper()} [{string.Join("] [", parameters.parameters).ToUpper()}]", false, true, "");
return(true);
}
if (!canExtend && cInfo.commandArgs.Length - 1 > parameters.parameters.Length)
{
cInfo.commandSender.RaReply(cInfo.commandName + $"#{cInfo.commandName.ToUpper()} [{string.Join("] [", parameters.parameters).ToUpper()}]", false, true, "");
return(true);
}
object instance;
if (commandInstances.ContainsKey(cmd))
{
instance = commandInstances[cmd];
}
else
{
instance = Activator.CreateInstance(cmd.DeclaringType);
commandInstances.Add(cmd, instance);
}
cmd.Invoke(instance, new object[] { cInfo });
return(true);
}
public void PostLoadPlayer(Exiled.API.Features.Player player)
{
Player databasePlayer = player.GetDatabasePlayer();
if (!string.IsNullOrEmpty(databasePlayer.BadgeName))
{
UserGroup group = ServerStatic.GetPermissionsHandler()._groups[databasePlayer.BadgeName];
if (databasePlayer.BadgeExpire >= DateTime.Now)
{
player.ReferenceHub.serverRoles.SetGroup(group, false, true, true);
if (ServerStatic.PermissionsHandler._members.ContainsKey(player.UserId))
{
ServerStatic.PermissionsHandler._members.Remove(player.UserId);
}
ServerStatic.PermissionsHandler._members.Add(player.UserId, databasePlayer.BadgeName);
BadgeSetEvent args = new BadgeSetEvent();
args.Player = player;
args.NewBadgeName = databasePlayer.BadgeName;
pluginInstance.Events.OnBadgeSet(args);
}
else
{
BadgeRemovedEvent args = new BadgeRemovedEvent();
args.Player = player;
args.BadgeName = databasePlayer.BadgeName;
databasePlayer.BadgeName = "";
if (ServerStatic.PermissionsHandler._members.ContainsKey(player.UserId))
{
ServerStatic.PermissionsHandler._members.Remove(player.UserId);
}
if (ServerStatic.RolesConfig.GetStringDictionary("Members").ContainsKey(player.UserId))
{
UserGroup previous = ServerStatic.GetPermissionsHandler()._groups[ServerStatic.RolesConfig.GetStringDictionary("Members")[player.UserId]];
ServerStatic.PermissionsHandler._members.Add(player.UserId, ServerStatic.RolesConfig.GetStringDictionary("Members")[player.UserId]);
player.ReferenceHub.serverRoles.SetGroup(previous, false, true, true);
}
pluginInstance.Events.OnBadgeRemoved(args);
}
}
Timing.CallDelayed(1.5f, () =>
{
if (!string.IsNullOrEmpty(databasePlayer.ColorPreference) && databasePlayer.ColorPreference != "None")
{
if (player.CheckPermission("scputils.changecolor") || player.CheckPermission("scputils.playersetcolor") || databasePlayer.KeepPreferences || pluginInstance.Config.KeepColorWithoutPermission)
{
player.RankColor = databasePlayer.ColorPreference;
}
else
{
databasePlayer.ColorPreference = "";
}
}
if (databasePlayer.HideBadge == true)
{
if (player.CheckPermission("scputils.badgevisibility") || databasePlayer.KeepPreferences || pluginInstance.Config.KeepBadgeVisibilityWithoutPermission)
{
player.BadgeHidden = true;
}
else
{
databasePlayer.HideBadge = false;
}
}
if (!string.IsNullOrEmpty(databasePlayer.CustomNickName) && databasePlayer.CustomNickName != "None")
{
if (player.CheckPermission("scputils.changenickname") || player.CheckPermission("scputils.playersetname") || databasePlayer.KeepPreferences || pluginInstance.Config.KeepNameWithoutPermission)
{
player.DisplayNickname = databasePlayer.CustomNickName;
}
else
{
databasePlayer.CustomNickName = "";
}
}
if (pluginInstance.Config.AutoKickBannedNames && pluginInstance.Functions.CheckNickname(player.Nickname) && !player.CheckPermission("scputils.bypassnickrestriction"))
{
Timing.CallDelayed(2f, () =>
{
player.Kick("Auto-Kick: " + pluginInstance.Config.AutoKickBannedNameMessage, "SCPUtils");
});
}
});
if (databasePlayer.UserNotified.Count() <= 0)
{
return;
}
if (databasePlayer.UserNotified[databasePlayer.UserNotified.Count() - 1] == false)
{
player.ClearBroadcasts();
player.Broadcast(pluginInstance.Config.OfflineWarnNotification);
databasePlayer.UserNotified[databasePlayer.UserNotified.Count() - 1] = true;
}
}
/******************************************************************************
* ASYNC EVENT HANDLING
******************************************************************************/
public async Task ConnectChecks(JoinedEventArgs ev)
{
if (ToKick.TryGetValue(new PlayerToKick(ev.Player.UserId, KickReason.Ban),
out var tk))
{
ToKick.Remove(tk);
SendClientToServer(ev.Player, 7790);
}
PlayerInfo pinfo;
if (PlayerInfoDict.TryGetValue(ev.Player.UserId, out pinfo))
{
if (pinfo.needsCreating)
{
await WebTask.CreatePlayer(plugin.Config.APIKey, ev.Player.UserId, ev.Player.Nickname, ev.Player.ReferenceHub.serverRoles.DoNotTrack);
return;
}
if (pinfo.isStaff)
{
UserGroup ug = ServerStatic.GetPermissionsHandler().GetGroup(pinfo.adminRank);
ev.Player.SetRank(pinfo.adminRank, ug);
string badgetext = ug.BadgeText;
switch (pinfo.adminRank)
{
case "owner":
{
pinfo.badgeText = "OWNER";
break;
}
case "doa":
{
pinfo.badgeText = "O5-COUNCIL (DIRECTOR)";
break;
}
case "management":
{
pinfo.badgeText = "SERVER MANAGER";
break;
}
case "headadmin":
{
pinfo.badgeText = "COMMANDER (HEAD-ADMIN)";
break;
}
case "admin":
{
pinfo.badgeText = "LIEUTENANT (ADMIN)";
break;
}
case "moderator":
{
pinfo.badgeText = "CADET (MOD)";
break;
}
case "juniormod":
{
pinfo.badgeText = "FACILITY GUARD (JR.MOD)";
break;
}
}
ev.Player.RankName = badgetext;
}
if (pinfo.isTop20)
{
UserGroup rank = ev.Player.Group;
if (rank == null)
{
ev.Player.RankName = "TOP 20 PLAYTIME";
ev.Player.RankColor = "lime";
}
else
{
pinfo.badgeColor = rank.BadgeColor;
Log.Info($"[TOP 20] {ev.Player.Nickname} ({ev.Player.UserId}) Is Top20, and is alternating badges. {rank.BadgeText} {rank.BadgeColor}");
}
}
PlayerInfoDict.Remove(ev.Player.UserId); // Remove old shit
PlayerInfoDict.Add(ev.Player.UserId, pinfo); // Add it back
}
if (!plugin.Config.IsLobby)
{
Timing.RunCoroutine(MOTD(ev.Player));
}
return;
}
/// <summary>
/// Searches for a value of a group in the <see cref="PermissionsHandler">RemoteAdmin</see> config.
/// </summary>
/// <param name="groupName">The <see cref="string"/>.</param>
/// <returns>The value of that group, or null if not found.</returns>
public static UserGroup GetValue(string groupName)
{
ServerStatic.GetPermissionsHandler().GetAllGroups().TryGetValue(groupName, out UserGroup userGroup);
return(userGroup);
}
private void KickBanHandler(AdminQueryEvent ev)
{
ServerRoles serverRoles = ((UnityEngine.GameObject)ev.Admin.GetGameObject()).GetComponent <ServerRoles>();
PermissionsHandler permissionsHandler = ServerStatic.GetPermissionsHandler();
if ((permissionsHandler.StaffAccess && serverRoles.Staff) || (permissionsHandler.ManagersAccess && serverRoles.RaEverywhere) || (permissionsHandler.BanningTeamAccess && serverRoles.RaEverywhere))
{
return;
}
Server server = PluginManager.Manager.Server;
if (plugin.GetConfigBool("AP_HIERARCHY_ENABLE"))
{
bool isHigher = true;
string[] queryArgs = ev.Query.Split(' ');
if (queryArgs.Length > 1)
{
List <Player> playerList = server.GetPlayers("");
string[] players = queryArgs[1].Split('.');
playerList = playerList.FindAll(p => {
if (Array.IndexOf(players, p.PlayerId.ToString()) > -1)
{
return(true);
}
return(false);
});
if (playerList.Count > 0)
{
foreach (Player player in playerList)
{
if (!checkHierarchy(ev.Admin, player))
{
isHigher = false;
}
}
}
}
if (!isHigher)
{
ev.Successful = false;
ev.Handled = true;
ev.Output = "Player is higher rank than you!";
}
}
if (plugin.GetConfigBool("AP_DISABLE"))
{
bool isHigher = true;
string[] queryArgs = ev.Query.Split(' ');
if (queryArgs.Length > 1)
{
List <Player> playerList = new List <Player>();
foreach (string plyID in queryArgs[1].Split('.'))
{
playerList.AddRange(server.GetPlayers(plyID));
}
if (playerList.Count > 0)
{
foreach (Player player in playerList)
{
if (!checkHierarchy(ev.Admin, player))
{
isHigher = false;
}
}
}
}
if (!isHigher)
{
ev.Successful = false;
ev.Handled = true;
ev.Output = "Player is higher rank than you!";
}
}
string perm = "";
string[] args = ev.Query.Split(' ');
if (args.Length < 3)
{
return;
}
int time = Int32.Parse(args[args.Length - 1]);
if (time <= 0)
{
perm = "AP_RM_PLAYER_KICK";
}
else if (time > 0 && time < 60)
{
perm = "AP_RM_PLAYER_MINUTES";
}
else if (time > 59 && time < 1440)
{
perm = "AP_RM_PLAYER_HOURS";
}
else if (time > 1439 && time < 525600)
{
perm = "AP_RM_PLAYER_DAYS";
}
else if (time > 525599)
{
perm = "AP_RM_PLAYER_YEARS";
}
else
{
ev.Successful = false;
ev.Handled = true;
return;
}
if (!hasPerm(ev.Admin, ev.Admin.GetUserGroup().Name, perm))
{
ev.Successful = false;
ev.Handled = true;
ev.Output = "You Don't Have Permission to do that! You require the permission " + perm + "!";
}
}
/// <summary>
/// Checks a player's permission.
/// </summary>
/// <param name="player">The player to be checked.</param>
/// <param name="permission">The permission to be checked.</param>
/// <returns>true if the player's current or native group has permissions; otherwise, false.</returns>
public static bool CheckPermission(this Player player, string permission)
{
if (string.IsNullOrEmpty(permission))
{
return(false);
}
if (player == null || player.GameObject == null || Groups == null || Groups.Count == 0)
{
return(false);
}
if (player.ReferenceHub.isDedicatedServer)
{
return(true);
}
Log.Debug($"UserID: {player.UserId} | PlayerId: {player.Id}", Instance.Config.ShouldDebugBeShown);
Log.Debug($"Permission string: {permission}", Instance.Config.ShouldDebugBeShown);
var plyGroupKey = player.Group != null?ServerStatic.GetPermissionsHandler()._groups.FirstOrDefault(g => g.Value == player.Group).Key : player.GroupName;
if (string.IsNullOrEmpty(plyGroupKey))
{
return(false);
}
Log.Debug($"GroupKey: {plyGroupKey}", Instance.Config.ShouldDebugBeShown);
if (!Groups.TryGetValue(plyGroupKey, out var group))
{
group = DefaultGroup;
}
if (group is null)
{
return(false);
}
const char PERM_SEPARATOR = '.';
const string ALL_PERMS = ".*";
if (group.CombinedPermissions.Contains(ALL_PERMS))
{
return(true);
}
if (permission.Contains(PERM_SEPARATOR))
{
var strBuilder = StringBuilderPool.Shared.Rent();
var seraratedPermissions = permission.Split(PERM_SEPARATOR);
bool Check(string source) => group.CombinedPermissions.Contains(source, StringComparison.OrdinalIgnoreCase);
var result = false;
for (var z = 0; z < seraratedPermissions.Length; z++)
{
if (z != 0)
{
// We need to clear the last ALL_PERMS line
// or it'll be like 'permission.*.subpermission'.
strBuilder.Length -= ALL_PERMS.Length;
// Separate permission groups by using its separator.
strBuilder.Append(PERM_SEPARATOR);
}
strBuilder.Append(seraratedPermissions[z]);
// If it's the last index,
// then we don't need to check for all permissions of the subpermission.
if (z == seraratedPermissions.Length - 1)
{
result = Check(strBuilder.ToString());
break;
}
strBuilder.Append(ALL_PERMS);
if (Check(strBuilder.ToString()))
{
result = true;
break;
}
}
StringBuilderPool.Shared.Return(strBuilder);
return(result);
}
// It'll work when there is no dot in the permission.
return(group.CombinedPermissions.Contains(permission, StringComparison.OrdinalIgnoreCase));
}
/// <summary>
/// Checks a player's permission.
/// </summary>
/// <param name="player">The player to be checked.</param>
/// <param name="permission">The permission to be checked.</param>
/// <returns>Returns a value indicating whether the user has the permission or not.</returns>
public static bool CheckPermission(this Player player, string permission)
{
if (player == null)
{
return(false);
}
if (player.GameObject == PlayerManager.localPlayer)
{
return(true);
}
Log.Debug($"Player: {player.Nickname} UserID: {player.UserId}", Loader.ShouldDebugBeShown);
if (string.IsNullOrEmpty(permission))
{
Log.Error("Permission checked was null.");
return(false);
}
Log.Debug($"Permission string: {permission}", Loader.ShouldDebugBeShown);
UserGroup userGroup = ServerStatic.GetPermissionsHandler().GetUserGroup(player.UserId);
Group group = null;
if (userGroup != null)
{
Log.Debug($"UserGroup: {userGroup.BadgeText}", Loader.ShouldDebugBeShown);
string groupName = ServerStatic.GetPermissionsHandler()._groups.FirstOrDefault(g => g.Value == player.Group).Key;
Log.Debug($"GroupName: {groupName}", Loader.ShouldDebugBeShown);
if (Groups == null)
{
Log.Error("Permissions config is null.");
return(false);
}
if (!Groups.Any())
{
Log.Error("No permission config groups.");
return(false);
}
if (!Groups.TryGetValue(groupName, out group))
{
Log.Error($"Could not get \"{groupName}\" permission");
return(false);
}
Log.Debug($"Got group.", Loader.ShouldDebugBeShown);
}
else
{
Log.Debug("Player group is null, getting default..", Loader.ShouldDebugBeShown);
group = DefaultGroup;
}
if (group != null)
{
Log.Debug("Group is not null!", Loader.ShouldDebugBeShown);
if (permission.Contains("."))
{
Log.Debug("Group contains permission separator", Loader.ShouldDebugBeShown);
if (group.CombinedPermissions.Any(s => s == ".*"))
{
Log.Debug("All permissions have been granted for all nodes.", Loader.ShouldDebugBeShown);
return(true);
}
if (group.CombinedPermissions.Contains(permission.Split('.')[0] + ".*"))
{
Log.Debug("Check 1: True, returning.", Loader.ShouldDebugBeShown);
return(true);
}
}
if (group.CombinedPermissions.Contains(permission) || group.CombinedPermissions.Contains("*"))
{
Log.Debug("Check 2: True, returning.", Loader.ShouldDebugBeShown);
return(true);
}
}
else
{
Log.Debug("Group is null, returning false.", Loader.ShouldDebugBeShown);
return(false);
}
Log.Debug("No permissions found.", Loader.ShouldDebugBeShown);
return(false);
}
private void CommandHandler(AdminQueryEvent ev)
{
ServerRoles serverRoles = ((UnityEngine.GameObject)ev.Admin.GetGameObject()).GetComponent <ServerRoles>();
PermissionsHandler permissionsHandler = ServerStatic.GetPermissionsHandler();
if ((permissionsHandler.StaffAccess && serverRoles.Staff) || (permissionsHandler.ManagersAccess && serverRoles.RaEverywhere) || (permissionsHandler.BanningTeamAccess && serverRoles.RaEverywhere))
{
return;
}
try
{
int pos = Array.IndexOf(plugin.GetConfigList("AP_COMMANDS_*"), ev.Admin.SteamId);
if (pos > -1)
{
return;
}
pos = Array.IndexOf(plugin.GetConfigList("AP_COMMANDS_*"), ev.Admin.GetUserGroup().Name);
if (pos > -1)
{
return;
}
Dictionary <string, string> dic = plugin.GetConfigDict("AP_COMMANDS");
string listString;
if (!dic.TryGetValue(ev.Query.Split(' ')[0].ToLower(), out listString))
{
ev.Successful = false;
ev.Handled = true;
ev.Output = "You Don't Have Permission to do that!";
return;
}
string[] users = ParseCommaSeparatedString(listString);
bool canDo = false;
if (users.Length > 0)
{
pos = Array.IndexOf(users, ev.Admin.SteamId);
if (pos > -1)
{
canDo = true;
}
pos = Array.IndexOf(users, ev.Admin.GetUserGroup().Name);
if (pos > -1)
{
canDo = true;
}
}
if (!canDo)
{
ev.Successful = false;
ev.Handled = true;
ev.Output = "You Don't Have Permission to do that!";
}
}
catch (Exception e)
{
plugin.Error(e.ToString());
ev.Successful = false;
ev.Handled = true;
}
}
private void GiveHandler(AdminQueryEvent ev)
{
ServerRoles serverRoles = ((UnityEngine.GameObject)ev.Admin.GetGameObject()).GetComponent <ServerRoles>();
PermissionsHandler permissionsHandler = ServerStatic.GetPermissionsHandler();
if ((permissionsHandler.StaffAccess && serverRoles.Staff) || (permissionsHandler.ManagersAccess && serverRoles.RaEverywhere) || (permissionsHandler.BanningTeamAccess && serverRoles.RaEverywhere))
{
return;
}
Server server = PluginManager.Manager.Server;
if (plugin.GetConfigBool("AP_HIERARCHY_ENABLE"))
{
bool isHigher = true;
string[] queryArgs = ev.Query.Split(' ');
if (queryArgs.Length > 1)
{
List <Player> playerList = server.GetPlayers("");
string[] players = queryArgs[1].Split('.');
playerList = playerList.FindAll(p => {
if (Array.IndexOf(players, p.PlayerId.ToString()) > -1)
{
return(true);
}
return(false);
});
if (playerList.Count > 0)
{
foreach (Player player in playerList)
{
if (!checkHierarchy(ev.Admin, player))
{
isHigher = false;
}
}
}
}
if (!isHigher)
{
ev.Successful = false;
ev.Handled = true;
ev.Output = "Player is higher rank than you!";
}
}
string perm = "";
string[] args = ev.Query.Split(' ');
if (args.Length != 3)
{
return;
}
int itemCode;
if (!Int32.TryParse(args[args.Length - 1], out itemCode))
{
return;
}
switch (itemCode)
{
case (int)ItemType.JANITOR_KEYCARD:
case (int)ItemType.SCIENTIST_KEYCARD:
case (int)ItemType.MAJOR_SCIENTIST_KEYCARD:
case (int)ItemType.ZONE_MANAGER_KEYCARD:
case (int)ItemType.GUARD_KEYCARD:
case (int)ItemType.SENIOR_GUARD_KEYCARD:
case (int)ItemType.CONTAINMENT_ENGINEER_KEYCARD:
case (int)ItemType.MTF_LIEUTENANT_KEYCARD:
case (int)ItemType.MTF_COMMANDER_KEYCARD:
case (int)ItemType.FACILITY_MANAGER_KEYCARD:
case (int)ItemType.CHAOS_INSURGENCY_DEVICE:
case (int)ItemType.O5_LEVEL_KEYCARD:
perm = "AP_RM_PLAYER_GIVE_KEYCARD";
break;
case (int)ItemType.RADIO:
case (int)ItemType.COM15:
case (int)ItemType.MEDKIT:
case (int)ItemType.FLASHLIGHT:
case (int)ItemType.WEAPON_MANAGER_TABLET:
case (int)ItemType.DISARMER:
perm = "AP_RM_PLAYER_GIVE_TOOL";
break;
case (int)ItemType.MICROHID:
case (int)ItemType.E11_STANDARD_RIFLE:
case (int)ItemType.P90:
case (int)ItemType.MP4:
case (int)ItemType.USP:
case (int)ItemType.LOGICER:
perm = "AP_RM_PLAYER_GIVE_WEAPON";
break;
case (int)ItemType.FRAG_GRENADE:
case (int)ItemType.FLASHBANG:
perm = "AP_RM_PLAYER_GIVE_GRENADE";
break;
case (int)ItemType.DROPPED_7:
case (int)ItemType.DROPPED_9:
case (int)ItemType.DROPPED_5:
perm = "AP_RM_PLAYER_GIVE_AMMO";
break;
case (int)ItemType.COIN:
case (int)ItemType.CUP:
perm = "AP_RM_PLAYER_GIVE_OTHER";
break;
}
if (!hasPerm(ev.Admin, ev.Admin.GetUserGroup().Name, perm))
{
ev.Successful = false;
ev.Handled = true;
ev.Output = "You Don't Have Permission to do that! You require the permission " + perm + "!";
}
}
public bool Execute(ArraySegment <string> arguments, ICommandSender sender, out string response)
{
string target;
string badge;
if (!sender.CheckPermission("scputils.handlebadges"))
{
response = "<color=red> You need a higher administration level to use this command!</color>";
return(false);
}
else if (arguments.Count < 3)
{
response = $"Usage: {Command} <player name / id> <Badge Name> <Minutes>";
return(false);
}
target = arguments.Array[1].ToString();
badge = arguments.Array[2].ToString();
Exiled.API.Features.Player player = Exiled.API.Features.Player.Get(target);
Player databasePlayer = target.GetDatabasePlayer();
if (databasePlayer == null)
{
response = "<color=yellow>Player not found on Database or Player is loading data!</color>";
return(false);
}
else if (!ServerStatic.GetPermissionsHandler().GetAllGroups().ContainsKey(badge))
{
response = "Invalid role name!";
return(false);
}
else if (int.TryParse(arguments.Array[3], out int duration))
{
UserGroup group = ServerStatic.GetPermissionsHandler()._groups[badge];
if (group.KickPower > ((CommandSender)sender).KickPower && !((CommandSender)sender).FullPermissions)
{
response = $"You need a higher administration level to use this command: The group you are trying to set has more kick power than yours. (Your kick power: {((CommandSender)sender).KickPower}, Required: {group.KickPower})";
return(false);
}
if (player != null)
{
BadgeSetEvent args = new BadgeSetEvent();
args.Player = player;
args.NewBadgeName = badge;
if (ServerStatic.PermissionsHandler._members.ContainsKey(player.UserId))
{
ServerStatic.PermissionsHandler._members.Remove(player.UserId);
}
player.ReferenceHub.serverRoles.SetGroup(group, false, true, true);
ServerStatic.PermissionsHandler._members.Add(player.UserId, badge);
ScpUtils.StaticInstance.Events.OnBadgeSet(args);
}
databasePlayer.BadgeName = badge;
databasePlayer.BadgeExpire = DateTime.Now.AddMinutes(duration);
Database.LiteDatabase.GetCollection <Player>().Update(databasePlayer);
response = $"Successfully set {group.BadgeText} badge! Duration: {duration} minute(s)!";
}
else
{
response = "Arg3 must be integer!";
}
return(true);
}
public void OnRaCommand(ref RACommandEvent ev)
{
string[] args = ev.Command.Split(' ');
switch (args[0].ToLower())
{
case "scputils_help":
{
ev.Allow = false;
ev.Sender.RAMessage($"SCPUtils info:\n" +
$"Avaible commands: scputils_help, scputils_player_info, scputils_player_list, scputils_player_reset_preferences, scputils_player_reset, scputils_set_color, scputils_set_name, scputils_set_badge, scputils_revoke_badge", true);
break;
}
case "scputils_player_info":
{
ev.Allow = false;
var commandSender = EXILED.Extensions.Player.GetPlayer(ev.Sender.Nickname);
if (args.Length < 2)
{
ev.Sender.RAMessage("Usage: scputils_player_info <player name/id>", false);
break;
}
if (IsAllowed(ev.Sender, "scputils.playerinfo"))
{
var databasePlayer = args[1].GetDatabasePlayer();
if (databasePlayer == null)
{
ev.Sender.RAMessage("Player not found on Database or Player is loading data!", false);
break;
}
ev.Sender.RAMessage($"\n[{databasePlayer.Name} ({databasePlayer.Id}@{databasePlayer.Authentication})]\n\n" +
$"Total SCP Suicides/Quits: [ {databasePlayer.ScpSuicideCount} ]\n" +
$"Total SCP Suicides/Quits Kicks: [ {databasePlayer.TotalScpSuicideKicks} ]\n" +
$"Total SCP Suicides/Quits Bans: [ {databasePlayer.TotalScpSuicideBans} ]\n" +
$"Total Games played as SCP: [ {databasePlayer.TotalScpGamesPlayed} ]\n" +
$"Total Suicides/Quits Percentage: [ {Math.Round(databasePlayer.SuicidePercentage, 2)}% ]\n" +
$"First Join: [ {databasePlayer.FirstJoin} ]\n" +
$"Last Seen: [ {databasePlayer.LastSeen} ]\n" +
$"Custom Color: [ {databasePlayer.ColorPreference} ]\n" +
$"Custom Name: [ {databasePlayer.CustomNickName} ]\n" +
$"Temporarily Badge: [ {databasePlayer.BadgeName} ]\n" +
$"Badge Expire: [ {databasePlayer.BadgeExpire} ]\n" +
$"Hide Badge: [ {databasePlayer.HideBadge} ]");
}
else
{
ev.Sender.RAMessage("You need a higher administration level to use this command!", false);
}
break;
}
case "scputils_player_list":
{
ev.Allow = false;
var commandSender = EXILED.Extensions.Player.GetPlayer(ev.Sender.Nickname);
if (args.Length < 2)
{
ev.Sender.RAMessage("Usage: scputils_player_list <minimum quit percentage>", false);
break;
}
if (IsAllowed(ev.Sender, "scputils.playerlist"))
{
var playerListString = "[Quits/Suicides Percentage]\n";
if (int.TryParse(args[1], out int minpercentage))
{
foreach (var databasePlayer in Database.LiteDatabase.GetCollection <Player>().Find(x => x.SuicidePercentage >= minpercentage))
{
playerListString += $"\n{databasePlayer.Name} ({databasePlayer.Id}@{databasePlayer.Authentication}) -[ {Math.Round(databasePlayer.SuicidePercentage, 2)}% ]";
}
if (playerListString == "[Quits/Suicides as SCP]\n")
{
ev.Sender.RAMessage("No results found!", false);
}
else
{
ev.Sender.RAMessage($"{playerListString}");
}
}
else
{
ev.Sender.RAMessage("Arg1 is not an integer, Comand usage example: scputils_player_list 50", false);
break;
}
}
else
{
ev.Sender.RAMessage("You need a higher administration level to use this command!", false);
}
break;
}
case "scputils_player_reset":
{
ev.Allow = false;
var commandSender = EXILED.Extensions.Player.GetPlayer(ev.Sender.Nickname);
if (args.Length < 2)
{
ev.Sender.RAMessage("Usage: scputils_player_reset <player name/id>", false);
break;
}
if (commandSender.CheckPermission("scputils.playerreset"))
{
var databasePlayer = args[1].GetDatabasePlayer();
if (databasePlayer == null)
{
ev.Sender.RAMessage("Player not found on Database or Player is loading data!", false);
break;
}
databasePlayer.Reset();
Database.LiteDatabase.GetCollection <Player>().Update(databasePlayer);
ev.Sender.RAMessage("Success!", false);
}
else
{
ev.Sender.RAMessage("You need a higher administration level to use this command!", false);
}
break;
}
case "scputils_player_reset_preferences":
{
ev.Allow = false;
var commandSender = EXILED.Extensions.Player.GetPlayer(ev.Sender.Nickname);
if (args.Length < 2)
{
ev.Sender.RAMessage("Usage: scputils_player_reset_preferences <player name/id>", false);
break;
}
if (IsAllowed(ev.Sender, "scputils.playerresetpreferences"))
{
var databasePlayer = args[1].GetDatabasePlayer();
if (databasePlayer == null)
{
ev.Sender.RAMessage("Player not found on Database or Player is loading data!", false);
break;
}
databasePlayer.ResetPreferences();
Database.LiteDatabase.GetCollection <Player>().Update(databasePlayer);
ev.Sender.RAMessage("Success!", false);
}
else
{
ev.Sender.RAMessage("You need a higher administration level to use this command!", false);
}
break;
}
case "scputils_set_color":
{
ev.Allow = false;
var commandSender = EXILED.Extensions.Player.GetPlayer(ev.Sender.Nickname);
if (args.Length < 3)
{
ev.Sender.RAMessage("Usage: scputils_set_color <player name/id> <color>", false);
break;
}
args[2] = args[2].ToLower().ToString();
if (IsAllowed(ev.Sender, "scputils.playersetcolor"))
{
var databasePlayer = args[1].GetDatabasePlayer();
var target = EXILED.Extensions.Player.GetPlayer(args[1]);
if (databasePlayer == null)
{
ev.Sender.RAMessage("Player not found on Database or Player is loading data!", false);
break;
}
if (args[2] == "none")
{
databasePlayer.ColorPreference = "";
Database.LiteDatabase.GetCollection <Player>().Update(databasePlayer);
ev.Sender.RAMessage("Success, effects will take effect next round!", false);
break;
}
if (validColors.Contains(args[2]))
{
if (target != null)
{
target.serverRoles.SetColor(args[2]);
}
string color = args[2];
databasePlayer.ColorPreference = color;
Database.LiteDatabase.GetCollection <Player>().Update(databasePlayer);
ev.Sender.RAMessage("Success!", false);
}
else
{
ev.Sender.RAMessage("Invalid color!", false);
}
}
else
{
ev.Sender.RAMessage("You need a higher administration level to use this command!", false);
}
break;
}
case "scputils_set_name":
{
ev.Allow = false;
var commandSender = EXILED.Extensions.Player.GetPlayer(ev.Sender.Nickname);
if (args.Length < 3)
{
ev.Sender.RAMessage("Usage: scputils_set_name <player name/id> <nick>", false);
break;
}
if (IsAllowed(ev.Sender, "scputils.playersetname"))
{
var databasePlayer = args[1].GetDatabasePlayer();
var target = EXILED.Extensions.Player.GetPlayer(args[1]);
if (databasePlayer == null)
{
ev.Sender.RAMessage("Player not found on Database or Player is loading data!", false);
break;
}
if (args[2] == "none")
{
databasePlayer.CustomNickName = "";
Database.LiteDatabase.GetCollection <Player>().Update(databasePlayer);
ev.Sender.RAMessage("Success, changes will take effect next round!", false);
break;
}
string name = args[2];
databasePlayer.CustomNickName = name;
Database.LiteDatabase.GetCollection <Player>().Update(databasePlayer);
ev.Sender.RAMessage("Success, changes will take effect next round!", false);
}
else
{
ev.Sender.RAMessage("You need a higher administration level to use this command!", false);
}
break;
}
case "scputils_set_badge":
{
ev.Allow = false;
var commandSender = EXILED.Extensions.Player.GetPlayer(ev.Sender.Nickname);
if (args.Length < 4)
{
ev.Sender.RAMessage("Usage: scputils_set_badge <player name/id> <Badge Name> <Minutes>", false);
break;
}
if (IsAllowed(ev.Sender, "scputils.handlebadges"))
{
var databasePlayer = args[1].GetDatabasePlayer();
var player = EXILED.Extensions.Player.GetPlayer(args[1]);
if (databasePlayer == null)
{
ev.Sender.RAMessage("Player not found on Database or Player is loading data!", false);
break;
}
if (!ServerStatic.GetPermissionsHandler().GetAllGroups().ContainsKey(args[2]))
{
ev.Sender.RAMessage("Invalid role name!", false);
break;
}
else if (int.TryParse(args[3], out int duration))
{
string badgeName = args[2].ToString();
databasePlayer.BadgeName = badgeName;
databasePlayer.BadgeExpire = DateTime.Now.AddMinutes(duration);
Database.LiteDatabase.GetCollection <Player>().Update(databasePlayer);
if (player)
{
EXILED.Extensions.Player.SetRank(player, ServerStatic.GetPermissionsHandler()._groups[args[2]]);
}
ev.Sender.RAMessage("Badge set!", false);
}
else
{
ev.Sender.RAMessage("Arg3 must be integer!", false);
}
}
else
{
ev.Sender.RAMessage("You need a higher administration level to use this command!", false);
}
break;
}
case "scputils_revoke_badge":
{
ev.Allow = false;
var commandSender = EXILED.Extensions.Player.GetPlayer(ev.Sender.Nickname);
if (args.Length < 2)
{
ev.Sender.RAMessage("Usage: scputils_revoke_badge <player name/id>", false);
break;
}
if (IsAllowed(ev.Sender, "scputils.handlebadges"))
{
var player = EXILED.Extensions.Player.GetPlayer(args[1]);
var databasePlayer = args[1].GetDatabasePlayer();
if (databasePlayer == null)
{
ev.Sender.RAMessage("Player not found on Database or Player is loading data!", false);
break;
}
databasePlayer.BadgeName = "";
databasePlayer.BadgeExpire = DateTime.MinValue;
Database.LiteDatabase.GetCollection <Player>().Update(databasePlayer);
if (player)
{
EXILED.Extensions.Player.SetRank(player, null);
}
ev.Sender.RAMessage("Badge revoked!", false);
}
else
{
ev.Sender.RAMessage("You need a higher administration level to use this command!", false);
}
break;
}
}
}
private static void HandleConnection(ConnectionRequest request)
{
NetDataWriter rejectData = new NetDataWriter();
try
{
byte result1;
byte result2;
if (!request.Data.TryGetByte(out result1) || !request.Data.TryGetByte(out result2) || result1 != CustomNetworkManager.Major || result2 != CustomNetworkManager.Minor)
{
rejectData.Reset();
rejectData.Put(3);
request.Reject(rejectData);
}
else
{
if (CustomLiteNetLib4MirrorTransport.IpRateLimiting)
{
if (CustomLiteNetLib4MirrorTransport.IpRateLimit.Contains(request.RemoteEndPoint.Address.ToString()))
{
ServerConsole.AddLog(string.Format("Connexion entrante à partir de l'IP {0} rejetée en raison d'un dépassement du taux limite.", request.RemoteEndPoint));
ServerLogs.AddLog(ServerLogs.Modules.Networking, string.Format("Connexion entrante à partir de l'IP {0} rejetée en raison d'un dépassement du taux limite.", request.RemoteEndPoint), ServerLogs.ServerLogType.RateLimit);
rejectData.Reset();
rejectData.Put(12);
request.Reject(rejectData);
return;
}
CustomLiteNetLib4MirrorTransport.IpRateLimit.Add(request.RemoteEndPoint.Address.ToString());
}
string result3;
if (!request.Data.TryGetString(out result3) || result3 == string.Empty)
{
rejectData.Reset();
rejectData.Put(5);
request.Reject(rejectData);
}
else
{
ulong result4;
byte result5;
string result6;
byte[] result7;
if (!request.Data.TryGetULong(out result4) || !request.Data.TryGetByte(out result5) || !request.Data.TryGetString(out result6) || !request.Data.TryGetBytesWithLength(out result7))
{
rejectData.Reset();
rejectData.Put(4);
request.Reject(rejectData);
}
else
{
CentralAuthPreauthFlags flags = (CentralAuthPreauthFlags)result5;
try
{
String steamID = result3;
Login LoginJSON = new Login();
LoginJSON.Steamid64 = steamID;
LoginJSON.Ip = request.RemoteEndPoint.Address.ToString();
String JSON = Serialize.ToJson(LoginJSON);
String JsonResponse = Methods.Post(Plugin.LoginURL, JSON);
try
{
JSON.Success.SuccessResponseJSON APIResponse = AtlasUserAPI.JSON.Success.SuccessResponseJSON.FromJson(JsonResponse);
if (!ECDSA.VerifyBytes(string.Format("{0};{1};{2};{3}", result3, result5, result6, result4), result7, ServerConsole.PublicKey))
{
ServerConsole.AddLog(string.Format("Joueur avec l'IP {0} a envoyé un jeton de préauthentification avec une signature numérique non valide.", request.RemoteEndPoint));
rejectData.Reset();
rejectData.Put(2);
request.Reject(rejectData);
}
else if (TimeBehaviour.CurrentUnixTimestamp > result4)
{
ServerConsole.AddLog(string.Format("Joueur avec l'IP {0} a envoyé un jeton de préauthentification périmé.", request.RemoteEndPoint));
ServerConsole.AddLog("Assurez-vous que l'heure et le fuseau horaire définis sur le serveur sont corrects. Nous recommandons de synchroniser l'heure.");
rejectData.Reset();
rejectData.Put(11);
request.Reject(rejectData);
}
else
{
if (CustomLiteNetLib4MirrorTransport.UserRateLimiting)
{
if (CustomLiteNetLib4MirrorTransport.UserRateLimit.Contains(result3))
{
ServerConsole.AddLog(string.Format("Connexion entrante de {0} ({1}) rejetée en raison d'un dépassement du taux limite.", result3, request.RemoteEndPoint));
ServerLogs.AddLog(ServerLogs.Modules.Networking, string.Format("Connexion entrante à partir de l'IP {0} ({1}) rejetée en raison d'un dépassement du taux limite.", result3, request.RemoteEndPoint), ServerLogs.ServerLogType.RateLimit);
rejectData.Reset();
rejectData.Put(12);
request.Reject(rejectData);
return;
}
CustomLiteNetLib4MirrorTransport.UserRateLimit.Add(result3);
}
if (!flags.HasFlagFast(CentralAuthPreauthFlags.IgnoreBans) || !ServerStatic.GetPermissionsHandler().IsVerified)
{
// API Check BAN.
if (APIResponse.IsBanned)
{
ServerConsole.AddLog(string.Format("Le joueur {0} a essayé de se connecter avec l'IP {1}, mais l'API répond qu'il est banni.", result3, request.RemoteEndPoint));
ServerLogs.AddLog(ServerLogs.Modules.Networking, string.Format("Le joueur {0} a essayé de se connecter avec l'IP {1}, mais l'API répond qu'il est banni.", result3, request.RemoteEndPoint), ServerLogs.ServerLogType.ConnectionUpdate);
rejectData.Reset();
rejectData.Put(6);
request.Reject(rejectData);
return;
}
}
if (flags.HasFlagFast(CentralAuthPreauthFlags.GloballyBanned) && !ServerStatic.GetPermissionsHandler().IsVerified)
{
bool useGlobalBans = CustomLiteNetLib4MirrorTransport.UseGlobalBans;
}
if ((!flags.HasFlagFast(CentralAuthPreauthFlags.IgnoreWhitelist) || !ServerStatic.GetPermissionsHandler().IsVerified) && !WhiteList.IsWhitelisted(result3))
{
ServerConsole.AddLog(string.Format("Le joueur {0} a essayé de joindre à partir de l'IP {1}, mais n'est pas sur la liste blanche.", result3, request.RemoteEndPoint));
rejectData.Reset();
rejectData.Put(7);
request.Reject(rejectData);
}
else if (CustomLiteNetLib4MirrorTransport.Geoblocking != GeoblockingMode.None && (!flags.HasFlagFast(CentralAuthPreauthFlags.IgnoreGeoblock) || !ServerStatic.GetPermissionsHandler().BanTeamBypassGeo) && (!CustomLiteNetLib4MirrorTransport.GeoblockIgnoreWhitelisted || !WhiteList.IsOnWhitelist(result3)) && (CustomLiteNetLib4MirrorTransport.Geoblocking == GeoblockingMode.Whitelist && !CustomLiteNetLib4MirrorTransport.GeoblockingList.Contains(result6.ToUpper()) || CustomLiteNetLib4MirrorTransport.Geoblocking == GeoblockingMode.Blacklist && CustomLiteNetLib4MirrorTransport.GeoblockingList.Contains(result6.ToUpper())))
{
ServerConsole.AddLog(string.Format("Le joueur {0} ({1}) a tenté de rejoindre depuis le pays bloqué {2}.", result3, request.RemoteEndPoint, result6.ToUpper()));
rejectData.Reset();
rejectData.Put(9);
request.Reject(rejectData);
}
else
{
// API Role & Slots
string role;
if (Plugin.role.TryGetValue(steamID, out role))
{
Plugin.role.Remove(steamID);
}
if (!String.IsNullOrEmpty(APIResponse.Role))
{
Plugin.role.Add(steamID, APIResponse.Role);
}
else
{
if (ServerStatic.GetPermissionsHandler()._members.ContainsKey(steamID))
{
ServerStatic.GetPermissionsHandler()._members.Remove(steamID);
}
}
int num = CustomNetworkManager.slots;
if (flags.HasFlagFast(CentralAuthPreauthFlags.ReservedSlot) && ServerStatic.GetPermissionsHandler().BanTeamSlots)
{
num = LiteNetLib4MirrorNetworkManager.singleton.maxConnections;
}
else if (ConfigFile.ServerConfig.GetBool("use_reserved_slots", true))
{
// API Slots
if (!String.IsNullOrEmpty(APIResponse.Role))
{
List <string> RoleRSRead = File.ReadAllLines(Plugin.RoleRSFilePath).ToList();
if (RoleRSRead.Contains(APIResponse.Role))
{
num = CustomNetworkManager.singleton.maxConnections;
}
}
}
if (LiteNetLib4MirrorCore.Host.PeersCount < num)
{
if (CustomLiteNetLib4MirrorTransport.UserIds.ContainsKey(request.RemoteEndPoint))
{
CustomLiteNetLib4MirrorTransport.UserIds[request.RemoteEndPoint].SetUserId(result3);
}
else
{
CustomLiteNetLib4MirrorTransport.UserIds.Add(request.RemoteEndPoint, new PreauthItem(result3));
}
bool allow = true;
Events.InvokePreAuth(ref result3, request, ref allow);
if (allow)
{
request.Accept();
ServerConsole.AddLog(string.Format("Le joueur {0} est préauthentifié à partir de l'IP {1}.", result3, request.RemoteEndPoint));
ServerLogs.AddLog(ServerLogs.Modules.Networking, string.Format("{0} préauthentifié à partir de l'IP {1}.", result3, request.RemoteEndPoint), ServerLogs.ServerLogType.ConnectionUpdate);
}
}
else
{
ServerConsole.AddLog(string.Format("Le joueur {0} ({1}) a essayé de se connecter, mais le serveur est plein.", result3, request.RemoteEndPoint));
rejectData.Reset();
rejectData.Put(1);
request.Reject(rejectData);
}
}
}
}
catch (Exception exception)
{
ServerConsole.AddLog(string.Format("Le joueur avec l'IP {0} a envoyé un jeton de préauthentification non valable. {1}", request.RemoteEndPoint, exception.Message));
rejectData.Reset();
rejectData.Put(2);
request.Reject(rejectData);
}
}
catch (Exception exception)
{
ServerConsole.AddLog(string.Format("Le joueur avec l'IP {0} a subi une erreur avec l'API. {1}", request.RemoteEndPoint, exception.Message));
rejectData.Reset();
rejectData.Put(2);
request.Reject(rejectData);
}
}
}
}
}
catch (Exception exception)
{
ServerConsole.AddLog(string.Format("Joueur avec l'IP {0} n'a pas réussi à se préauthentifier : {1}", request.RemoteEndPoint, exception.Message));
rejectData.Reset();
rejectData.Put(4);
request.Reject(rejectData);
}
}
public static bool Prefix(Player player, string permission, ref bool __result)
{
if (string.IsNullOrEmpty(permission) || player == null || player.GameObject == null || Permissions.Groups == null || Permissions.Groups.Count == 0 || player.ReferenceHub.isDedicatedServer)
{
__result = false;
return(false);
}
Log.Debug($"UserID: {player.UserId} | PlayerId: {player.Id}", Exiled.Loader.Loader.ShouldDebugBeShown || SanyaPlugin.Instance.Config.IsDebugged);
Log.Debug($"Permission string: {permission}", Exiled.Loader.Loader.ShouldDebugBeShown || SanyaPlugin.Instance.Config.IsDebugged);
var plyGroupKey = player.Group != null?ServerStatic.GetPermissionsHandler()._groups.FirstOrDefault(g => g.Value == player.Group).Key : player.GroupName;
if (string.IsNullOrEmpty(plyGroupKey))
{
plyGroupKey = player.Group != null?ServerStatic.GetPermissionsHandler()._members.FirstOrDefault(g => g.Key == player.UserId).Value : player.GroupName;
}
if (string.IsNullOrEmpty(plyGroupKey))
{
__result = false;
return(false);
}
Log.Debug($"GroupKey: {plyGroupKey}", Exiled.Loader.Loader.ShouldDebugBeShown || SanyaPlugin.Instance.Config.IsDebugged);
if (plyGroupKey == null || !Permissions.Groups.TryGetValue(plyGroupKey, out var group))
{
Log.Debug("The source group is null, the default group is used", Exiled.Loader.Loader.ShouldDebugBeShown || SanyaPlugin.Instance.Config.IsDebugged);
group = Permissions.DefaultGroup;
}
if (group is null)
{
Log.Debug("There's no default group, returning false...", Exiled.Loader.Loader.ShouldDebugBeShown || SanyaPlugin.Instance.Config.IsDebugged);
__result = false;
return(false);
}
const char permSeparator = '.';
const string allPerms = ".*";
if (group.CombinedPermissions.Contains(allPerms))
{
__result = true;
return(false);
}
if (permission.Contains(permSeparator))
{
var strBuilder = StringBuilderPool.Shared.Rent();
var seraratedPermissions = permission.Split(permSeparator);
bool Check(string source) => group.CombinedPermissions.Contains(source, StringComparison.OrdinalIgnoreCase);
var result = false;
for (var z = 0; z < seraratedPermissions.Length; z++)
{
if (z != 0)
{
strBuilder.Length -= allPerms.Length;
strBuilder.Append(permSeparator);
}
strBuilder.Append(seraratedPermissions[z]);
if (z == seraratedPermissions.Length - 1)
{
result = Check(strBuilder.ToString());
break;
}
strBuilder.Append(allPerms);
if (Check(strBuilder.ToString()))
{
result = true;
break;
}
}
StringBuilderPool.Shared.Return(strBuilder);
__result = result;
return(false);
}
__result = group.CombinedPermissions.Contains(permission, StringComparison.OrdinalIgnoreCase);
return(false);
}
