public ShardedDiscordClient (DiscordSocketConfig discordSocketConfig)
        {
            _log = LogManager.GetCurrentClassLogger();
            this.discordSocketConfig = discordSocketConfig;

            var clientList = new List<DiscordSocketClient>();
            for (int i = 0; i < discordSocketConfig.TotalShards; i++)
            {
                discordSocketConfig.ShardId = i;
                var client = new DiscordSocketClient(discordSocketConfig);
                clientList.Add(client);
                client.UserJoined += async arg1 => await UserJoined(arg1);
                client.MessageReceived += async arg1 => await MessageReceived(arg1);
                client.UserLeft += async arg1 => await UserLeft(arg1);
                client.UserUpdated += async (arg1, gu2) => await UserUpdated(arg1, gu2);
                client.MessageUpdated += async (arg1, m2) => await MessageUpdated(arg1, m2);
                client.MessageDeleted += async (arg1, arg2) => await MessageDeleted(arg1, arg2);
                client.UserBanned += async (arg1, arg2) => await UserBanned(arg1, arg2);
                client.UserPresenceUpdated += async (arg1, arg2, arg3) => await UserPresenceUpdated(arg1, arg2, arg3);
                client.UserVoiceStateUpdated += async (arg1, arg2, arg3) => await UserVoiceStateUpdated(arg1, arg2, arg3);
                client.ChannelCreated += async arg => await ChannelCreated(arg);
                client.ChannelDestroyed += async arg => await ChannelDestroyed(arg);
                client.ChannelUpdated += async (arg1, arg2) => await ChannelUpdated(arg1, arg2);

                _log.Info($"Shard #{i} initialized.");
            }

            Clients = clientList.AsReadOnly();
        }
Esempio n. 2
0
        public async Task StartAsync()
        {
            var client = new DiscordSocketClient();
            Bot.Client = client;
            Bot.Client.Log += Client_Log;

            _commands = new CommandsPlugin(Bot.Client);
            _admincommands = new CommandsPlugin(Bot.Client, (e, s) => { return BotTools.Tools.GetPerms(s, e as IGuildUser); }, '-');
            _commands.CreateCommandGroup("", group => BuildCommands(group));
            _admincommands.CreateCommandGroup("", adminGroup => BuildAdminCommands(adminGroup));

            BotTools.Setup.GetProgramInfo();

            Bot.Client.UserJoined += BotTools.ChatEventActions.UserJoinedAsync;
            Bot.Client.UserLeft += BotTools.ChatEventActions.UserLeftAsync;
            Bot.Client.UserBanned += BotTools.ChatEventActions.UserBannedAsync;
            Bot.Client.MessageReceived += BotTools.ChatEventActions.MessageReceivedAsync;
            Bot.Client.Disconnected += BotTools.ChatEventActions.DisconnectedAsync;


            _commands.CommandError += async (s, e) =>
            {
                if (e.Command.Text == "ayy")
                    return;

                var ex = e.Exception;
                if (ex is PermissionException)
                    await BotTools.Tools.ReplyAsync(e, "Sorry, you do not have the permissions to use this command!");
                else
                    await BotTools.Tools.ReplyAsync(e, $"Error: {ex.Message}.");

            };

            
            await Modules.AnimeTools.AuthorizeAnilistAsync();
            await LoginAsync();

            await Task.Delay(-1);

        }
Esempio n. 3
0
        static async Task Main(string[] args)
        {
            // Configure services
            var services = configureServices(new ServiceCollection()).BuildServiceProvider();

            using (services.CreateScope())
            {
                _logger  = services.GetService <ILogger <Program> >();
                _discord = services.GetService <DiscordSocketClient>();

                // Load configuration
                await LoadConfigAsync();

                // Register events
                _discord.Log             += handleLogAsync;
                _discord.MessageReceived += handleMessageAsync;

                // Login
                var connectionSource = new TaskCompletionSource <object>();

                _discord.Connected += handleConnect;
                Task handleConnect()
                {
                    connectionSource.SetResult(null);
                    return(Task.CompletedTask);
                }

                await _discord.LoginAsync(TokenType.User, _config.AuthToken);

                await _discord.StartAsync();

                await connectionSource.Task;

                _discord.Connected -= handleConnect;

                // Keep the bot running
                // TODO: graceful shutdown?
                while (true)
                {
                    if (_config.AutoRollInterval.HasValue)
                    {
                        await Task.Delay(TimeSpan.FromMinutes(_config.AutoRollInterval.Value));

                        await sendRollAsync();
                    }
                    else
                    {
                        await Task.Delay(1000);
                    }
                }

                // Unregister events
                _discord.Log             -= handleLogAsync;
                _discord.MessageReceived -= handleMessageAsync;

                // Logout
                await _discord.StopAsync();

                await _discord.LogoutAsync();
            }
        }
Esempio n. 4
0
        internal async Task ConnectAsync(NaggerknifeBotConfig config)
        {
            _client = new DiscordSocketClient(config.SocketConfig);

            _client.Log += _logger.Log;
        }
Esempio n. 5
0
        public StatsService(DiscordSocketClient client, CommandHandler cmdHandler,
                            IBotCredentials creds, EvilMortyBot evilMorty,
                            IDataCache cache)
        {
            _log    = LogManager.GetCurrentClassLogger();
            _client = client;
            _creds  = creds;
            _redis  = cache.Redis;

            _started = DateTime.UtcNow;
            _client.MessageReceived    += _ => Task.FromResult(Interlocked.Increment(ref _messageCounter));
            cmdHandler.CommandExecuted += (_, e) => Task.FromResult(Interlocked.Increment(ref _commandsRan));

            _client.ChannelCreated += (c) =>
            {
                var _ = Task.Run(() =>
                {
                    if (c is ITextChannel)
                    {
                        Interlocked.Increment(ref _textChannels);
                    }
                    else if (c is IVoiceChannel)
                    {
                        Interlocked.Increment(ref _voiceChannels);
                    }
                });

                return(Task.CompletedTask);
            };

            _client.ChannelDestroyed += (c) =>
            {
                var _ = Task.Run(() =>
                {
                    if (c is ITextChannel)
                    {
                        Interlocked.Decrement(ref _textChannels);
                    }
                    else if (c is IVoiceChannel)
                    {
                        Interlocked.Decrement(ref _voiceChannels);
                    }
                });

                return(Task.CompletedTask);
            };

            _client.GuildAvailable += (g) =>
            {
                var _ = Task.Run(() =>
                {
                    var tc = g.Channels.Count(cx => cx is ITextChannel);
                    var vc = g.Channels.Count - tc;
                    Interlocked.Add(ref _textChannels, tc);
                    Interlocked.Add(ref _voiceChannels, vc);
                });
                return(Task.CompletedTask);
            };

            _client.JoinedGuild += (g) =>
            {
                var _ = Task.Run(() =>
                {
                    var tc = g.Channels.Count(cx => cx is ITextChannel);
                    var vc = g.Channels.Count - tc;
                    Interlocked.Add(ref _textChannels, tc);
                    Interlocked.Add(ref _voiceChannels, vc);
                });
                return(Task.CompletedTask);
            };

            _client.GuildUnavailable += (g) =>
            {
                var _ = Task.Run(() =>
                {
                    var tc = g.Channels.Count(cx => cx is ITextChannel);
                    var vc = g.Channels.Count - tc;
                    Interlocked.Add(ref _textChannels, -tc);
                    Interlocked.Add(ref _voiceChannels, -vc);
                });

                return(Task.CompletedTask);
            };

            _client.LeftGuild += (g) =>
            {
                var _ = Task.Run(() =>
                {
                    var tc = g.Channels.Count(cx => cx is ITextChannel);
                    var vc = g.Channels.Count - tc;
                    Interlocked.Add(ref _textChannels, -tc);
                    Interlocked.Add(ref _voiceChannels, -vc);
                });

                return(Task.CompletedTask);
            };

            if (_client.ShardId == 0)
            {
                _carbonitexTimer = new Timer(async(state) =>
                {
                    if (string.IsNullOrWhiteSpace(_creds.CarbonKey))
                    {
                        return;
                    }
                    try
                    {
                        using (var http = new HttpClient())
                        {
                            using (var content = new FormUrlEncodedContent(
                                       new Dictionary <string, string> {
                                { "servercount", evilMorty.GuildCount.ToString() },
                                { "key", _creds.CarbonKey }
                            }))
                            {
                                content.Headers.Clear();
                                content.Headers.Add("Content-Type", "application/x-www-form-urlencoded");

                                await http.PostAsync("https://www.carbonitex.net/discord/data/botdata.php", content).ConfigureAwait(false);
                            }
                        }
                    }
                    catch
                    {
                        // ignored
                    }
                }, null, TimeSpan.FromHours(1), TimeSpan.FromHours(1));
            }

            _botlistTimer = new Timer(async(state) =>
            {
                if (string.IsNullOrWhiteSpace(_creds.BotListToken))
                {
                    return;
                }
                try
                {
                    using (var http = new HttpClient())
                    {
                        using (var content = new FormUrlEncodedContent(
                                   new Dictionary <string, string> {
                            { "shard_count", _creds.TotalShards.ToString() },
                            { "shard_id", client.ShardId.ToString() },
                            { "server_count", client.Guilds.Count().ToString() }
                        }))
                        {
                            content.Headers.Clear();
                            content.Headers.Add("Content-Type", "application/x-www-form-urlencoded");
                            http.DefaultRequestHeaders.Add("Authorization", _creds.BotListToken);

                            await http.PostAsync($"https://discordbots.org/api/bots/{client.CurrentUser.Id}/stats", content).ConfigureAwait(false);
                        }
                    }
                }
                catch (Exception ex)
                {
                    _log.Error(ex);
                    // ignored
                }
            }, null, TimeSpan.FromMinutes(5), TimeSpan.FromHours(1));

            var platform = "other";

            if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
            {
                platform = "linux";
            }
            else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
            {
                platform = "osx";
            }
            else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                platform = "windows";
            }

            _dataTimer = new Timer(async(state) =>
            {
                try
                {
                    using (var http = new HttpClient())
                    {
                        using (var content = new FormUrlEncodedContent(
                                   new Dictionary <string, string> {
                            { "id", string.Concat(MD5.Create().ComputeHash(Encoding.ASCII.GetBytes(_creds.ClientId.ToString())).Select(x => x.ToString("X2"))) },
                            { "guildCount", evilMorty.GuildCount.ToString() },
                            { "version", BotVersion },
                            { "platform", platform }
                        }))
                        {
                            content.Headers.Clear();
                            content.Headers.Add("Content-Type", "application/x-www-form-urlencoded");

                            await http.PostAsync("https://selfstats.evilMortybot.me/", content).ConfigureAwait(false);
                        }
                    }
                }
                catch
                {
                    // ignored
                }
            }, null, TimeSpan.FromSeconds(1), TimeSpan.FromHours(1));
        }
Esempio n. 6
0
 public CommandHandler(DiscordSocketClient client, CommandService commands, IServiceProvider services)
 {
     _client   = client;
     _commands = commands;
     _services = services;
 } // end Constructor
Esempio n. 7
0
 public Watcher(DiscordSocketClient client) : base(client)
 {
     _autoPastebin = new AutoPastebin();
     _imageParser  = new ImageParser();
 }
Esempio n. 8
0
 public ChannelController(DiscordSocketClient client, IAuthorizationService modixAuth, IDesignatedChannelService channelService) : base(client, modixAuth)
 {
     ChannelService = channelService;
 }
Esempio n. 9
0
 public static async Task <SocketMessage> WaitForMessageAsync(this SocketChannel channel, DiscordSocketClient client, TimeSpan timeout, Func <SocketMessage, bool> filter)
 {
     return(await client.WaitForMessageAsync(timeout, (message) => (message.Channel.Id == channel.Id && filter(message))));
 }
        public DiscordAccessor(DiscordSocketClient Client, DiscordRestClient RClient)
        {
            this.Client = Client;

            this.RClient = RClient;
        }
 public DiscordReactionHandler(DiscordSocketClient client, RecipeService recipeService)
 {
     _client        = client;
     _recipeService = recipeService;
 }
Esempio n. 12
0
 public DiscordBotContext(DiscordSocketClient client, SocketUserMessage message)
 {
     this.Client      = client;
     this.Message     = message;
     this.MessageData = BotMessageData.Create(Message, this.Settings);
 }
Esempio n. 13
0
 public HangmanCommands(DiscordSocketClient client)
 {
     _client = client;
 }
Esempio n. 14
0
 public TicTacToeCommands(DiscordSocketClient client)
 {
     _client = client;
 }
Esempio n. 15
0
 public EventService(IServiceProvider _services)
 {
     services = _services;
     client   = services.GetRequiredService <DiscordSocketClient>();
 }
Esempio n. 16
0
        private async Task MainAsync(string[] args, ILogger logger)
        {
            this.logger = logger;
            this.args   = args;
            logger.Information("[Geekbot] Initing Stuff");

            client = new DiscordSocketClient(new DiscordSocketConfig
            {
                LogLevel            = LogSeverity.Verbose,
                MessageCacheSize    = 1000,
                AlwaysDownloadUsers = true
            });
            client.Log += DiscordLogger;
            commands    = new CommandService();

            try
            {
                var redisMultiplexer = ConnectionMultiplexer.Connect("127.0.0.1:6379");
                redis = redisMultiplexer.GetDatabase(6);
                logger.Information($"[Redis] Connected to db {redis.Database}");
            }
            catch (Exception e)
            {
                logger.Fatal(e, "[Redis] Redis Connection Failed");
                Environment.Exit(102);
            }

            if (args.Contains("--migrate"))
            {
                Console.WriteLine("\nYou are about to migrate the database, this will overwrite an already migrated database?");
                Console.Write("Are you sure [y:N]: ");
                var migrateDbConfirm = Console.ReadKey();
                Console.WriteLine();
                if (migrateDbConfirm.Key == ConsoleKey.Y)
                {
                    logger.Warning("[Geekbot] Starting Migration");
                    await DbMigration.MigrateDatabaseToHash(redis, logger);

                    logger.Warning("[Geekbot] Finished Migration");
                }
                else
                {
                    logger.Information("[Geekbot] Not Migrating db");
                }
            }

            token = redis.StringGet("discordToken");
            if (token.IsNullOrEmpty)
            {
                Console.Write("Your bot Token: ");
                var newToken = Console.ReadLine();
                redis.StringSet("discordToken", newToken);
                redis.StringSet("Game", "Ping Pong");
                token      = newToken;
                firstStart = true;
            }

            services = new ServiceCollection();

            userRepository = new UserRepository(redis, logger);
            var errorHandler  = new ErrorHandler(logger);
            var RandomClient  = new Random();
            var fortunes      = new FortunesProvider(RandomClient, logger);
            var checkEmImages = new CheckEmImageProvider(RandomClient, logger);
            var pandaImages   = new PandaProvider(RandomClient, logger);
            var malClient     = new MalClient(redis, logger);

            services.AddSingleton <IErrorHandler>(errorHandler);
            services.AddSingleton(redis);
            services.AddSingleton <ILogger>(logger);
            services.AddSingleton <IUserRepository>(userRepository);
            services.AddSingleton(RandomClient);
            services.AddSingleton <IFortunesProvider>(fortunes);
            services.AddSingleton <ICheckEmImageProvider>(checkEmImages);
            services.AddSingleton <IPandaProvider>(pandaImages);
            services.AddSingleton <IMalClient>(malClient);

            logger.Information("[Geekbot] Connecting to Discord");

            await Login();

            await Task.Delay(-1);
        }
Esempio n. 17
0
 public GameActionsModule(Game game, DiscordSocketClient client, DiscordClientWrapper clientWrapper)
 {
     _game          = game;
     _client        = client;
     _clientWrapper = clientWrapper;
 }
        public DiggingJobProvider(IDataStorage dataStorage, GlobalUserDataProvider userProvider, DiscordSocketClient client)
        {
            _client = client;
            _ds     = dataStorage;
            _gudp   = userProvider;

            try
            {
                _activeJobs = dataStorage.Get <List <DiggingJob> >(DataStorageKey);
            }
            catch (DataStorageKeyDoesNotExistException)
            {
                _activeJobs = new List <DiggingJob>();
                dataStorage.Store(_activeJobs, DataStorageKey);
            }
        }
Esempio n. 19
0
        public static async Task <bool> IsBotOwner([NotNull] this ClaimsPrincipal user, DiscordSocketClient client)
        {
            var discordUser = user.TryGetDiscordUser(client);

            if (discordUser == null)
            {
                return(false);
            }

            var info = await client.GetApplicationInfoAsync();

            if (info.Owner == null)
            {
                return(false);
            }

            return(info.Owner.Id == discordUser.Id);
        }
Esempio n. 20
0
 public Connect4Commands(DiscordSocketClient client, ICurrencyService cs, GamblingConfigService gamb)
     : base(gamb)
 {
     _client = client;
     _cs     = cs;
 }
Esempio n. 21
0
        public static async Task <bool> IsInBotGuild([NotNull] this ClaimsPrincipal user, DiscordSocketClient client)
        {
            var discordUser = user.TryGetDiscordUser(client);

            if (discordUser == null)
            {
                return(false);
            }

            return(discordUser.MutualGuilds.Count > 0);
        }
Esempio n. 22
0
 public ReadyEvent(bool addToAll, DiscordSocketClient discord, ILogger logger) {
     _addToAll = addToAll;
     _discord = discord;
     _manager = new Manager(Assets.MONGO_DB_CONNECTION_QUERY);
     _logger = logger;
 }
Esempio n. 23
0
        public static SocketUser TryGetDiscordUser([NotNull] this ClaimsPrincipal user, DiscordSocketClient client)
        {
            var idClaim = user.FindFirst(c => c.Type == ClaimTypes.NameIdentifier && c.Issuer == "Discord");

            if (idClaim == null)
            {
                return(null);
            }

            if (!ulong.TryParse(idClaim.Value ?? "", out var id))
            {
                return(null);
            }

            return(client.GetUser(id));
        }
Esempio n. 24
0
        public static void Main(string[] args)
        {
            ApplicationBase = Path.GetDirectoryName(new Uri(Assembly.GetEntryAssembly().CodeBase).LocalPath);
            if (!File.Exists(Path.Combine(ApplicationBase, "Opux.db")))
            {
                File.Copy(ApplicationBase + "/Opux.def.db", Path.Combine(ApplicationBase, "Opux.db"));
            }

            //_zKillhttpClient.Timeout = new TimeSpan(0, 0, 10);
            //_zKillhttpClient.DefaultRequestHeaders.Add("User-Agent", "OpuxBot");

            UpdateSettings();

            Client = new DiscordSocketClient(new DiscordSocketConfig()
            {
            });
            Commands = new CommandService();
            EveLib   = new EveLib();
            MainAsync().GetAwaiter().GetResult();

            var headless = Convert.ToBoolean(Settings.GetSection("config")["Systemd_Support"]);

            if (!headless)
            {
                var dockerMode = Environment.GetEnvironmentVariable("DOCKER_MODE");

                if (dockerMode != null)
                {
                    Logger.DiscordClient_Log(new LogMessage(LogSeverity.Info, "Docker", "Docker mode enabled")).Wait();
                    if (dockerMode == "debug")
                    {
                        Logger.DiscordClient_Log(new LogMessage(LogSeverity.Info, "Docker", "Debug mode enabled")).Wait();
                        debug = true;
                    }

                    System.Runtime.Loader.AssemblyLoadContext.Default.Unloading += ctx =>
                    {
                        Logger.DiscordClient_Log(new LogMessage(LogSeverity.Info, "Docker", "Received termination signal")).Wait();
                        lock (ExitLock)
                        {
                            Monitor.Pulse(ExitLock);
                        }
                        ended.Wait();
                    };

                    lock (ExitLock)
                    {
                        Logger.DiscordClient_Log(new LogMessage(LogSeverity.Info, "Docker", "Waiting for termination")).Wait();
                        Monitor.Wait(ExitLock);
                        Logger.DiscordClient_Log(new LogMessage(LogSeverity.Info, "Docker", "Exiting")).Wait();
                        quit = true;
                    }
                }

                while (!quit)
                {
                    var command = Console.ReadLine();
                    switch (command.Split(" ")[0])
                    {
                    case "quit":
                        Console.WriteLine($"Quitting Opux");
                        quit = true;
                        break;

                    case "debug":
                        if (!debug)
                        {
                            Console.WriteLine($"Debug mode Active");
                            debug = true;
                        }
                        else
                        {
                            Console.WriteLine($"Debug mode Disabled");
                            debug = false;
                        }
                        break;

                    case "admin":
                        var guild      = Client.GetGuild(Convert.ToUInt64(Settings.GetSection("config")["guildId"]));
                        var rolesToAdd = new List <SocketRole>();
                        var GuildRoles = guild.Roles;
                        guild.GetUser(Convert.ToUInt64(command.Split(" ")[2])).AddRoleAsync(GuildRoles.FirstOrDefault(x => x.Name == command.Split(" ")[1]));
                        break;
                    }
                }
            }
            else
            {
                Logger.DiscordClient_Log(new LogMessage(LogSeverity.Info, "Headless", "Headless mode enabled")).Wait();

                System.Runtime.Loader.AssemblyLoadContext.Default.Unloading += ctx =>
                {
                    Logger.DiscordClient_Log(new LogMessage(LogSeverity.Info, "Headless", "Received termination signal")).Wait();
                    lock (ExitLock)
                    {
                        Monitor.Pulse(ExitLock);
                    }
                    ended.Wait();
                };

                lock (ExitLock)
                {
                    Logger.DiscordClient_Log(new LogMessage(LogSeverity.Info, "Headless", "Waiting for termination")).Wait();
                    Monitor.Wait(ExitLock);
                    Logger.DiscordClient_Log(new LogMessage(LogSeverity.Info, "Headless", "Exiting")).Wait();
                    quit = true;
                }
            }
            Client.StopAsync();
            ended.Set();
        }
Esempio n. 25
0
        public async Task Start()
        {
            Console.Title = "Kratos";

            // Set up our Discord client
            _client = new DiscordSocketClient(new DiscordSocketConfig()
            {
                LogLevel         = LogSeverity.Verbose,
                MessageCacheSize = 100
            });

            _client.Log += Log;

            // Set up the config directory and core config
            if (!Directory.Exists(Path.Combine(Directory.GetCurrentDirectory(), "config")))
            {
                Directory.CreateDirectory(Path.Combine(Directory.GetCurrentDirectory(), "config"));
            }

            if (File.Exists(Path.Combine(Directory.GetCurrentDirectory(), "config", "core.json")))
            {
                _config = await CoreConfig.UseCurrentAsync();
            }
            else
            {
                _config = await CoreConfig.CreateNewAsync();
            }

            // Set up services
            _mod = new ModerationService();
            await _mod.LoadConfigurationAsync();

            _usernotes = new UsernoteService();

            _records = new RecordService();

            _tags = new TagService();

            _log = new LogService(_client);
            await _log.LoadConfigurationAsync();

            _unpunish = new UnpunishService(_client, _blacklist, _log, _records, _config);
            await _unpunish.GetRecordsAsync();

            _slowmode = new SlowmodeService(_client, _log, _unpunish, _records, _config);

            _ratelimit = new RatelimitService(_client, _config, _records, _unpunish, _log);
            await _ratelimit.LoadConfigurationAsync();

            if (_ratelimit.IsEnabled)
            {
                _ratelimit.Enable(_ratelimit.Limit);
            }

            _blacklist = new BlacklistService(_client, _unpunish, _records, _log, _config);

            _aliases = new AliasTrackingService(_client);
            await _aliases.LoadConfigurationAsync();

            _permissions = new PermissionsService();
            _permissions.LoadPermissions(Assembly.GetEntryAssembly());
            await _permissions.LoadConfigurationAsync();

            // Instantiate the dependency map and add our services and client to it.
            var serviceProvider = ConfigureServices();

            // Set up command handler
            _commands = new CommandHandler(serviceProvider);
            await _commands.InstallAsync();

            // Set up an event handler to execute some state-reliant startup tasks
            _client.Ready += async() =>
            {
                await _blacklist.LoadConfigurationAsync();
            };
            // Connect to Discord
            await _client.LoginAsync(TokenType.Bot, _config.Token);

            await _client.StartAsync();

            // Start unpunisher loop
            await _unpunish.StartAsync();

            // Hang indefinitely
            await Task.Delay(-1);
        }
Esempio n. 26
0
 public DiscordTasksService(IDiscordUserService discordUserService, DiscordSocketClient discord, IConfigurationRoot config)
 {
     this._discordUserService = discordUserService;
     this._discord            = discord;
     this._config             = config;
 }
Esempio n. 27
0
        public async Task MainAsync()
        {
            ILoggerRepository logRepository = LogManager.GetRepository(Assembly.GetEntryAssembly());

            XmlConfigurator.Configure(logRepository, new FileInfo("log4net.config"));
            InitializeDirectories();
            StartTime = DateTime.Now;
            string[] moods = { "Sad", "Meh", "Happy", "Extatic" };

            //download content
            using (var client = new WebClient())
            {
                foreach (string item in moods)
                {
                    if (!File.Exists($"mood/{item}.png"))
                    {
                        client.DownloadFile($"https://cdn.its-sally.net/content/{item}.png", $"mood/{item}.png");
                    }
                    if (!File.Exists($"mood/{item}.json"))
                    {
                        client.DownloadFile($"https://cdn.its-sally.net/content/{item}.json", $"mood/{item}.json");
                    }
                }
            }

            BotConfiguration = JsonConvert.DeserializeObject <BotCredentials>(File.ReadAllText("config/configuration.json"));
            await DatabaseAccess.InitializeAsync(BotConfiguration.DbUser, BotConfiguration.DbPassword, BotConfiguration.Db, BotConfiguration.DbHost);

            CredentialManager = new ConfigManager(BotConfiguration);


            if (!File.Exists("meta/prefix.json"))
            {
                File.Create("meta/prefix.json").Dispose();
            }
            //store in database
            prefixDictionary = new Dictionary <ulong, char>();
            prefixDictionary = JsonConvert.DeserializeObject <Dictionary <ulong, char> >(File.ReadAllText("meta/prefix.json"));
            if (prefixDictionary == null)
            {
                prefixDictionary = new Dictionary <ulong, char>();
            }

            if (!File.Exists("ApiRequests.txt"))
            {
                // Create a file to write to.
                using (StreamWriter sw = File.CreateText("ApiRequests.txt"))
                {
                    sw.WriteLine("0");
                    sw.Close();
                }
            }
            RequestCounter = Int32.Parse(File.ReadAllText("ApiRequests.txt"));

            Client = new DiscordSocketClient();


            Client.Ready += Client_Ready;
            Client.Log   += Log;

            await Client.LoginAsync(TokenType.Bot, BotConfiguration.Token);

            await Client.StartAsync();

            // Block this task until the program is closed.
            await Task.Delay(-1);
        }
Esempio n. 28
0
 public CommandHandler(DiscordSocketClient client, CommandService commands)
 {
     _commands = commands;
     _client   = client;
 }
 public ModerationLogService(DataService data, DiscordSocketClient client, LoggingService log)
 {
     _data   = data;
     _client = client;
     _log    = log;
 }
Esempio n. 30
0
        public async Task MainAsync()
        {
            _client   = new DiscordSocketClient();
            _commands = new CommandService();
            _services = new ServiceCollection()
                        .AddSingleton(_client)
                        .AddSingleton(_commands)
                        .BuildServiceProvider();

            var token = "paste your token here";

            events = new Events.Events(_client, _commands, _services);

            _client.Log                   += events.Log;
            _client.ReactionAdded         += events.ReactionAdded;
            _client.ReactionRemoved       += events.ReactionRemoved;
            _client.UserVoiceStateUpdated += events.UserVoiceStateUpdated;

            await _client.SetGameAsync("Among Us", null, ActivityType.Playing);

            await RegisterCommandsAsync();

            await _client.LoginAsync(TokenType.Bot, token);

            await _client.StartAsync();

            await Task.Delay(2500);

            foreach (var guild in _client.Guilds)
            {
                bool  deleted     = false;
                ulong _categoryId = 0;

                foreach (var category in guild.CategoryChannels.ToList())
                {
                    if (string.Compare(category.Name, Config.LobbyCategoryName, true) == 0)
                    {
                        _categoryId = category.Id;
                        break;
                    }
                }

                if (_categoryId > 0 && guild.VoiceChannels.Count > 0)
                {
                    foreach (var vChan in guild.VoiceChannels)
                    {
                        if (vChan.CategoryId == _categoryId && vChan.Name != Config.VoiceChannelHub)
                        {
                            deleted = true;
                            await vChan.DeleteAsync();
                        }
                    }
                }

                var ranks = guild.Roles.Where(x => x.Name.StartsWith(Config.VoiceRoomPrefix));
                if (ranks.Count() > 0)
                {
                    foreach (var rank in ranks)
                    {
                        deleted = true;
                        await rank.DeleteAsync();
                    }
                }

                if (_categoryId > 0 && deleted)
                {
                    foreach (var chan in guild.TextChannels)
                    {
                        if (chan.Name == Config.LobbyCategoryName && chan.CategoryId == _categoryId)
                        {
                            await chan.SendMessageAsync(Strings.AutoRestartMessageWhenCrash(guild.Roles.Max().Mention));
                        }
                    }
                }
            }

            // Block this task until the program is closed.
            await Task.Delay(-1);
        }
Esempio n. 31
0
 public AutoReactService(HttpClient httpClient, DiscordSocketClient client, IConfigProvider configProvider)
 {
     this.httpClient     = httpClient;
     this.client         = client;
     this.configProvider = configProvider;
 }
Esempio n. 32
0
        public CommandsPlugin(DiscordSocketClient client, Func<SocketUser, ulong, int> getPermissions = null, char commandChar = '/')
        {
            _client = client;
            _getPermissions = getPermissions;
            Commands = new List<Command>();

            CommandChar = commandChar;
            UseCommandChar = true;

            var timeValues = new Dictionary<SocketUser, Dictionary<Command, DateTime>>();

            client.MessageReceived += async (message) =>
            {
                //Don't bother to process if there are no commands.
                if (Commands.Count == 0)
                    return;

                //Ignore ourselves.
                if (message.Author.Id == _client.CurrentUser.Id)
                    return;


                string msg = message.Content;
                if (UseCommandChar)
                {
                    if (msg.Length == 0)
                        return;

                    if (msg[0] == CommandChar)
                        msg = msg.Substring(1);
                    else
                        return;
                }

                CommandPart[] args;
                if (!CommandParser.ParseArgs(msg, out args))
                    return;

                try
                {

                    foreach (var command in Commands)
                    {
                        if (args.Length < command.Parts.Length)
                            continue;

                        bool isValid = true;
                        for (int i = 0; i < command.Parts.Length; i++)
                        {
                            if (!string.Equals(args[i].Value, command.Parts[i], StringComparison.OrdinalIgnoreCase))
                            {
                                isValid = false;
                                break;
                            }
                        }

                        //Check if alias
                        if (command.alias != null)
                        {
                            foreach (var alias in command.alias)
                            {
                                if (args[0].Value == alias)
                                {
                                    isValid = true;
                                    break;
                                }
                            }
                        }

                        if (!isValid)
                            continue;

                        //Check Arg Count.
                        int argCount = args.Length - command.Parts.Length;
                        if (argCount < command.MinArgs || argCount > command.MaxArgs)
                            continue;

                        //Clean Args brb getting drinks got milk kek
                        string[] newArgs = new string[argCount];
                        for (int i = 0; i < newArgs.Length; i++)
                            newArgs[i] = args[i + command.Parts.Length].Value;

                        //Get ArgText
                        string argText;
                        if (argCount == 0)
                            argText = String.Empty;
                        else
                            argText = msg.Substring(args[command.Parts.Length].Index);

                        //Check perms
                        int permissions = getPermissions != null ? getPermissions(message.Author, ((Discord.ITextChannel)message.Channel).Guild.Id) : 0;
                        var eventArgs = new CommandArgs(message, command, msg, argText, permissions, newArgs);
                        if (permissions < command.MinPerms)
                        {
                            await BotTools.Tools.ReplyAsync(message.Author, message.Channel, "You do not have the correct permissions to use this command.", true);
                            return;
                        }

                        //try to delete the message if the parameter is set.
                        try
                        {
                            if (command.IsHidden && (message.Channel as IPrivateChannel) == null)
                                await message.DeleteAsync();
                        }
                        catch (Exception) { }

                        if (message.Channel as IPrivateChannel == null)
                        {
                            //check if admin, if so he can ignore the time constraint and shit.
                            bool timeCheck = true;
                            if (!command.DelayUnignorable)
                            {
                                var info = BotTools.Tools.GetServerInfo(((ITextChannel)message.Channel).GuildId);
                                if (info.roleImportancy.Count > 0)
                                {
                                    for (int i = 0; i < info.roleImportancy.Count; i++)
                                    {
                                        ulong importantRole = info.roleImportancy.Keys.ToArray()[i];
                                        int importantRoleAmnt = info.roleImportancy.Values.ToArray()[i];
                                        SocketRole role = (message.Channel as ITextChannel)?.Guild.GetRole(importantRole) as SocketRole;

                                        if (role == null) continue;

                                        if ((message.Author as IGuildUser).RoleIds.Contains(role.Id) && importantRoleAmnt >= 15)
                                        {
                                            timeCheck = false;
                                            break;
                                        }
                                    }
                                }
                            }


                            //Check if outside of time limit
                            if (command.CommandDelay != null)
                            {
                                if (timeCheck)
                                {
                                    Dictionary<Command, DateTime> dict;
                                    DateTime time;

                                    //if the user does not have a key, make one. Then get the key.
                                    if (!timeValues.ContainsKey(message.Author))
                                        timeValues.Add(message.Author, new Dictionary<Command, DateTime>());

                                    dict = timeValues[message.Author];

                                    bool skipTimeCheck = false;
                                    //The above gets the time, and if that returns null it adds the current command with the current time to the dict. Then exit the while function.
                                    if (!dict.ContainsKey(command))
                                    {
                                        dict.Add(command, DateTime.UtcNow);
                                        skipTimeCheck = true;
                                    }

                                    if (!skipTimeCheck)
                                    {
                                        time = dict[command];
                                        double test = (DateTime.UtcNow - time).TotalSeconds;
                                        if ((DateTime.UtcNow - time).TotalSeconds < command.CommandDelay)
                                        {
                                            string waitTime = String.Empty;
                                            int seconds = (int)(command.CommandDelay - (DateTime.UtcNow - time).TotalSeconds);

                                            #region time calculator
                                            int days, hours, minutes = 0;

                                            minutes = seconds / 60;
                                            seconds %= 60;
                                            hours = minutes / 60;
                                            minutes %= 60;
                                            days = hours / 24;
                                            hours %= 24;

                                            if (days > 0)
                                            {
                                                string postfix;
                                                if (days == 1)
                                                    postfix = "day";
                                                else
                                                    postfix = "days";

                                                waitTime += $"{days} {postfix}";
                                            }

                                            if (hours > 0)
                                            {
                                                if (waitTime.Length > 0)
                                                    waitTime += ", ";

                                                string postfix;
                                                if (hours == 1)
                                                    postfix = "hour";
                                                else
                                                    postfix = "hours";
                                                waitTime += $"{hours} {postfix}";
                                            }

                                            if (minutes > 0)
                                            {
                                                if (waitTime.Length > 0)
                                                    waitTime += ", ";

                                                string postfix;
                                                if (minutes == 1)
                                                    postfix = "minute";
                                                else
                                                    postfix = "minutes";
                                                waitTime += $"{minutes} {postfix}";
                                            }

                                            if (seconds > 0)
                                            {
                                                if (waitTime.Length > 0)
                                                    waitTime += " and ";

                                                string postfix;
                                                if (seconds == 1)
                                                    postfix = "second";
                                                else
                                                    postfix = "seconds";
                                                waitTime += $"{seconds} {postfix}";
                                            }
                                            #endregion

                                            if (command.FailHandler == null)
                                                await ((ITextChannel)eventArgs.Channel).SendMessageAsync($"{message.Author.Mention}: You need to wait {waitTime} before you can use /{command.Parts[0]}.");
                                            else
                                            {
                                                try
                                                {
                                                    //why is this here
                                                }
                                                catch (Exception ex)
                                                {
                                                    RaiseCommandError(eventArgs, ex);
                                                }
                                            }
                                            return;
                                        }
                                    }

                                    dict[command] = DateTime.UtcNow;
                                }
                            }
                        }

                        //Run Command
                        Console.WriteLine($"[CommandEvent] {message.Author.Username} used command: {String.Join("", eventArgs.Command.Parts)}.");
                        RaiseRanCommand(eventArgs);
                        try
                        {
                            var task = command.Handler(eventArgs);
                            if (task != null)
                                await task;
                        }
                        catch (Exception ex)
                        {
                            RaiseCommandError(eventArgs, ex);
                            Console.WriteLine(ex);  
                        }
                        break;
                    }

                }
                catch (Exception ex)
                {
                    await BotTools.Tools.ReplyAsync(message.Author, message.Channel, $"Plugin error: {ex.Message}", true);
                    BotTools.Tools.LogError("Error with plugin or something.", ex.Message);
                }

            };

        }
 public ReactionRoleCommands(InteractivityService interactivity, IGuildConfigRepository repo, ILoggingService logging, DiscordSocketClient client, ReactionRoleService rrService, IReactionRoleRuleRepository rrRepo)
 {
     logging.Info("Initialising Reaction Role Command Service");
     _interactivity = interactivity;
     _repo          = repo;
     _rrService     = rrService;
     _rrRepo        = rrRepo;
     _logging       = new SourcedLoggingService(logging, "RRCmds");
     _client        = client.Rest;
 }