Ejemplo n.º 1
0
        /// <summary>
        /// Unbans the player
        /// </summary>
        public void Unban()
        {
            // Check if unbanned already
            if (!IsBanned)
            {
                return;
            }

            // Set to unbanned
            SteamBlacklist.unban(cSteamId);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Unbans the user
        /// </summary>
        public void Unban()
        {
            // Check not banned
            if (!IsBanned)
            {
                return;
            }

            // Set to unbanned
            SteamBlacklist.unban(cSteamId);
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Unbans the player
        /// </summary>
        /// <param name="id"></param>
        public void Unban(string id)
        {
            // Check if unbanned already
            if (!IsBanned(id))
            {
                return;
            }

            // Set to unbanned
            SteamBlacklist.unban(new CSteamID(ulong.Parse(id)));
        }
        public async Task <bool> UnbanAsync(IUser target, IUser bannedBy = null)
        {
            UserUnbanEvent @event = new UserUnbanEvent(target, bannedBy);

            eventManager.Emit(host, @event);
            if (@event.IsCancelled)
            {
                return(false);
            }

            var steamId = new CSteamID(ulong.Parse(target.Id));

            return(SteamBlacklist.unban(steamId));
        }
Ejemplo n.º 5
0
        public override void Execute(PointBlankPlayer executor, string[] args)
        {
            if (!PlayerTool.tryGetSteamID(args[0], out CSteamID id))
            {
                UnturnedChat.SendMessage(executor, Translations["Base_InvalidPlayer"], ConsoleColor.Red);
                return;
            }

            if (!SteamBlacklist.unban(id))
            {
                UnturnedChat.SendMessage(executor, string.Format(Translations["Unban_NotBanned"], id), ConsoleColor.Red);
                return;
            }
            UnturnedChat.SendMessage(executor, string.Format(Translations["Unban_Unban"], id), ConsoleColor.Green);
        }
        public bool Unban(IUserInfo target, IUser bannedBy = null)
        {
            var player = ((UnturnedUser)target).Player;

            PlayerUnbanEvent @event = new PlayerUnbanEvent(player.User, bannedBy);

            eventManager.Emit(host, @event);
            if (@event.IsCancelled)
            {
                return(false);
            }

            var steamId = new CSteamID(ulong.Parse(target.Id));

            return(SteamBlacklist.unban(steamId));
        }
Ejemplo n.º 7
0
        public void Execute(IRocketPlayer caller, params string[] command)
        {
            if (command.Length != 1)
            {
                UnturnedChat.Say(caller, GlobalBan.Instance.Translate("command_generic_invalid_parameter"));
                return;
            }

            fr34kyn01535.GlobalBan.DatabaseManager.UnbanResult name = GlobalBan.Instance.Database.UnbanPlayer(command[0]);
            if (!SteamBlacklist.unban(new CSteamID(name.Id)) && String.IsNullOrEmpty(name.Name))
            {
                UnturnedChat.Say(caller, GlobalBan.Instance.Translate("command_generic_player_not_found"));
                return;
            }
            else
            {
                UnturnedChat.Say("The player " + name.Name + " was unbanned");
            }
        }
Ejemplo n.º 8
0
        public void Execute(IRocketPlayer caller, params string[] param)
        {
            CSteamID judge = (CSteamID)0;

            if (!(caller is ConsolePlayer))
            {
                judge = ((UnturnedPlayer)caller).CSteamID;
            }
            if (param.Length == 0)
            {
                if (Init.Instance.Configuration.Instance.LogIDonjoin)
                {
                    Init.Instance.Configuration.Save();
                    UnturnedChat.Say(caller, "Players already logged when they joined");
                    return;
                }
                else
                {
                    //if logindonjoin false
                    if (Provider.clients.Count == 0)
                    {
                        UnturnedChat.Say(caller, "No one available");
                        return;
                    }
                    else
                    {
                        List <CSteamID> ids = Provider.clients.Select(x => x.playerID.steamID).ToList();


                        if (!ids.Any())
                        {
                            return;
                        }
                        foreach (var player in ids)
                        {
                            FilterData.FilterData.Instance.Configuration.Instance.Unwhitelisted = ids.Except(FilterData.FilterData.Instance.Configuration.Instance.Whitelists).ToList();
                            FilterData.FilterData.Instance.Configuration.Save();
                            foreach (var playerid in FilterData.FilterData.Instance.Configuration.Instance.Unwhitelisted)
                            {
                                UnturnedChat.Say(caller, playerid.ToString());
                            }

                            UnturnedChat.Say(caller, "IDs saved locally");
                        }
                    }
                }
                return;
            }
            if (param.Length > 0)
            {
                if (param.Length == 1)
                {
                    switch (param[0])
                    {
                    case "debug":

                        if (!FilterData.FilterData.Instance.Configuration.Instance.Unwhitelisted.Any())
                        {
                            UnturnedChat.Say(caller, "Tban list is empty");
                            return;
                        }


                        foreach (var player in FilterData.FilterData.Instance.Configuration.Instance.Unwhitelisted)
                        {
                            UnturnedChat.Say(caller, player.ToString());
                        }


                        break;

                    case "unban":



                        if (!FilterData.FilterData.Instance.Configuration.Instance.Unwhitelisted.Any())
                        {
                            UnturnedChat.Say(caller, "Tban list is empty");
                            return;
                        }



                        foreach (var player in FilterData.FilterData.Instance.Configuration.Instance.Unwhitelisted.ToList())
                        {
                            Init.Instance.Database.UnbanPlayer(player.ToString());

                            SteamBlacklist.unban(player);
                            //CommandWindow.input.onInputText("unban " + player.ToString());
                            UnturnedChat.Say(caller, "Unbanned " + player + " and relieved from Globalban");
                        }

                        break;

                    case "ban":


                        if (!FilterData.FilterData.Instance.Configuration.Instance.Unwhitelisted.Any())
                        {
                            UnturnedChat.Say(caller, "Tban list is empty");
                            return;
                        }
                        else
                        {
                            foreach (var player in FilterData.FilterData.Instance.Configuration.Instance.Unwhitelisted)
                            {
                                /*ulong? otherPlayerID = player.GetCSteamID;
                                 * UnturnedPlayer playern = UnturnedPlayer.FromCSteamID(player);*/



                                Init.Instance.Database.BanPlayer("Tourneybanned", player.ToString(), "Tourneyban", "[TourneyCore Filter]", 2147483647);

                                Provider.kick(player, Init.Instance.Translate("Filter_Reason"));
                                SteamBlacklist.ban(player, Init.Instance.GetIP(player), judge, Init.Instance.Translate("Filter_Reason"), 2147483647);


                                UnturnedChat.Say("Kicked " + player);
                                //UnturnedChat.Say(caller, "" + player + " Tourneyban");
                            }
                        }

                        //EArenaState.SPAWN.



                        break;

                    case "enable":
                        if (Init.Instance.Configuration.Instance.LogIDonjoin == true)
                        {
                            UnturnedChat.Say(caller, "Logging on join is already enabled");
                            return;
                        }
                        UnturnedChat.Say(caller, "Enabling logging on join");
                        Init.Instance.Configuration.Instance.LogIDonjoin = true;
                        Init.Instance.Configuration.Save();
                        break;

                    case "disable":
                        if (Init.Instance.Configuration.Instance.LogIDonjoin == false)
                        {
                            UnturnedChat.Say(caller, "Logging on join is already disabled");
                            return;
                        }
                        UnturnedChat.Say(caller, "Disabling logging on join");
                        Init.Instance.Configuration.Instance.LogIDonjoin = false;
                        Init.Instance.Configuration.Save();
                        break;

                    case "clear":
                        if (!FilterData.FilterData.Instance.Configuration.Instance.Unwhitelisted.Any())
                        {
                            UnturnedChat.Say(caller, "List already empty");
                            return;
                        }
                        FilterData.FilterData.Instance.Configuration.Instance.Unwhitelisted.Clear();
                        FilterData.FilterData.Instance.Configuration.Save();
                        UnturnedChat.Say(caller, "Successfully cleared Tban list");
                        break;
                    }
                }
                else
                {
                    UnturnedChat.Say(caller, "Wrong syntax!");
                }
            }



            if (param.Length != 1 && param.Length != 0)
            {
                UnturnedChat.Say(caller, "Wrong syntax");
            }
        }