Esempio n. 1
0
        public async Task HandleRemoveAsync(MessageReactionRemoveEventArgs eventArgs)
        {
            using IServiceScope scope = _provider.CreateScope();

            foreach (Type reactionHandlerType in _reactionsHandlers)
            {
                IReactionHandler handler = scope.ServiceProvider.GetService(reactionHandlerType) as IReactionHandler
                                           ?? throw new ArgumentOutOfRangeException();
                var shouldStop = await handler.HandleRemoveAsync(eventArgs).ConfigureAwait(false);

                if (shouldStop == IReactionHandler.Result.Stop)
                {
                    return;
                }
            }
        }
Esempio n. 2
0
        public ClientManager(IMessageHandler messageHandler, IReactionHandler reactionHandler, ILogger <ClientManager> logger, IDiscordClient client, TwitchClient twitchClient)
        {
            _logger       = logger;
            _client       = client;
            _twitchClient = twitchClient;
            switch (_client)
            {
            case DiscordSocketClient discordSocketClient:
                // Create and attach restart service
                _reliabilityService = new ReliabilityService(discordSocketClient, true, Config.ServiceProvider.GetService <ILogger <ReliabilityService> >());
                _reliabilityService.Attach();

                // Attach event handlers
                discordSocketClient.MessageReceived += messageHandler.HandleAsync;
                discordSocketClient.ReactionAdded   += reactionHandler.HandleAsync;
                discordSocketClient.UserJoined      += OnUserJoinAsync;
                discordSocketClient.UserLeft        += OnUserLeaveAsync;
                discordSocketClient.UserBanned      += OnUserBanAsync;

                discordSocketClient.Ready += () =>
                {
                    _ready = true;
                    return(Task.CompletedTask);
                };

                // Add logging
                discordSocketClient.Log += logMessage =>
                {
                    switch (logMessage.Severity)
                    {
                    case LogSeverity.Critical:
                        _logger.LogCritical(logMessage.Exception, logMessage.Message);
                        break;

                    case LogSeverity.Error:
                        _logger.LogError(logMessage.Exception, logMessage.Message);
                        break;

                    case LogSeverity.Warning:
                        _logger.LogWarning(logMessage.Exception, logMessage.Message);
                        break;

                    case LogSeverity.Info:
                        _logger.LogInformation(logMessage.Exception, logMessage.Message);
                        break;

                    case LogSeverity.Verbose:
                        _logger.LogDebug(logMessage.Exception, logMessage.Message);
                        break;

                    case LogSeverity.Debug:
                        _logger.LogTrace(logMessage.Exception, logMessage.Message);
                        break;

                    default:
                        throw new ArgumentOutOfRangeException();
                    }
                    return(Task.CompletedTask);
                };
                break;
            }
        }