Example #1
0
            static LogCommands()
            {
                _client = FaultyBot.Client;
                _log    = LogManager.GetCurrentClassLogger();

                using (var uow = DbHandler.UnitOfWork())
                {
                    GuildLogSettings = new ConcurrentDictionary <ulong, LogSetting>(FaultyBot.AllGuildConfigs
                                                                                    .ToDictionary(g => g.GuildId, g => g.LogSetting));
                }

                timerReference = new Timer(async(state) =>
                {
                    try
                    {
                        var keys = UserPresenceUpdates.Keys.ToList();

                        await Task.WhenAll(keys.Select(async key =>
                        {
                            List <string> messages;
                            if (UserPresenceUpdates.TryRemove(key, out messages))
                            {
                                try { await key.SendMessageAsync(string.Join(Environment.NewLine, messages)); } catch { }
                            }
                        }));
                    }
                    catch (Exception ex)
                    {
                        _log.Warn(ex);
                    }
                }, null, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10));
            }
Example #2
0
            private Task _client_UserPresenceUpdated(IGuildUser usr, IPresence before, IPresence after)
            {
                LogSetting logSetting;

                if (!GuildLogSettings.TryGetValue(usr.Guild.Id, out logSetting) ||
                    !logSetting.LogUserPresence ||
                    before.Status == after.Status)
                {
                    return(Task.CompletedTask);
                }

                ITextChannel logChannel;

                if ((logChannel = TryGetLogChannel(usr.Guild, logSetting, LogChannelType.UserPresence)) == null)
                {
                    return(Task.CompletedTask);
                }
                string str;

                if (before.Status != after.Status)
                {
                    str = $"🔵`{prettyCurrentTime}`👤__**{usr.Username}**__ is now **{after.Status}**.";
                }
                else
                {
                    str = $"👾`{prettyCurrentTime}`👤__**{usr.Username}**__ is now playing **{after.Game}**.";
                }

                UserPresenceUpdates.AddOrUpdate(logChannel, new List <string>()
                {
                    str
                }, (id, list) => { list.Add(str); return(list); });

                return(Task.CompletedTask);
            }
Example #3
0
            private static async void _client_UserVoiceStateUpdated(SocketUser iusr, SocketVoiceState before, SocketVoiceState after)
            {
                try
                {
                    var usr = iusr as IGuildUser;
                    if (usr == null)
                    {
                        return;
                    }

                    var beforeVch = before.VoiceChannel;
                    var afterVch  = after.VoiceChannel;

                    if (beforeVch == afterVch)
                    {
                        return;
                    }

                    LogSetting logSetting;
                    if (!GuildLogSettings.TryGetValue(usr.Guild.Id, out logSetting) ||
                        (logSetting.LogVoicePresenceId == null))
                    {
                        return;
                    }

                    ITextChannel logChannel;
                    if ((logChannel = await TryGetLogChannel(usr.Guild, logSetting, LogType.VoicePresence)) == null)
                    {
                        return;
                    }

                    string str = null;
                    if (beforeVch?.Guild == afterVch?.Guild)
                    {
                        str = $"🎙`{prettyCurrentTime}`👤__**{usr.Username}#{usr.Discriminator}**__ moved from **{beforeVch.Name}** to **{afterVch.Name}** voice channel.";
                    }
                    else if (beforeVch == null)
                    {
                        str = $"🎙`{prettyCurrentTime}`👤__**{usr.Username}#{usr.Discriminator}**__ has joined **{afterVch.Name}** voice channel.";
                    }
                    else if (afterVch == null)
                    {
                        str = $"🎙`{prettyCurrentTime}`👤__**{usr.Username}#{usr.Discriminator}**__ has left **{beforeVch.Name}** voice channel.";
                    }
                    if (str != null)
                    {
                        UserPresenceUpdates.AddOrUpdate(logChannel, new List <string>()
                        {
                            str
                        }, (id, list) => { list.Add(str); return(list); });
                    }
                }
                catch (Exception ex)
                {
                    _log.Warn(ex);
                }
            }
Example #4
0
            private Task _client_UserVoiceStateUpdated(IUser iusr, IVoiceState before, IVoiceState after)
            {
                var usr = iusr as IGuildUser;

                if (usr == null)
                {
                    return(Task.CompletedTask);
                }

                var beforeVch = before.VoiceChannel;
                var afterVch  = after.VoiceChannel;

                if (beforeVch == afterVch)
                {
                    return(Task.CompletedTask);
                }

                LogSetting logSetting;

                if (!GuildLogSettings.TryGetValue(usr.Guild.Id, out logSetting) ||
                    !logSetting.LogVoicePresence)
                {
                    return(Task.CompletedTask);
                }

                ITextChannel logChannel;

                if ((logChannel = TryGetLogChannel(usr.Guild, logSetting, LogChannelType.Voice)) == null)
                {
                    return(Task.CompletedTask);
                }

                string str = null;

                if (beforeVch?.Guild == afterVch?.Guild)
                {
                    str = $"🎙`{prettyCurrentTime}`👤__**{usr.Username}#{usr.Discriminator}**__ moved from **{beforeVch.Name}** to **{afterVch.Name}** voice channel.";
                }
                else if (beforeVch == null)
                {
                    str = $"🎙`{prettyCurrentTime}`👤__**{usr.Username}#{usr.Discriminator}**__ has joined **{afterVch.Name}** voice channel.";
                }
                else if (afterVch == null)
                {
                    str = $"🎙`{prettyCurrentTime}`👤__**{usr.Username}#{usr.Discriminator}**__ has left **{beforeVch.Name}** voice channel.";
                }
                if (str != null)
                {
                    UserPresenceUpdates.AddOrUpdate(logChannel, new List <string>()
                    {
                        str
                    }, (id, list) => { list.Add(str); return(list); });
                }

                return(Task.CompletedTask);
            }
Example #5
0
            static LogCommands()
            {
                _client = NadekoBot.Client;
                _log    = LogManager.GetCurrentClassLogger();
                var sw = Stopwatch.StartNew();

                using (var uow = DbHandler.UnitOfWork())
                {
                    GuildLogSettings = new ConcurrentDictionary <ulong, LogSetting>(NadekoBot.AllGuildConfigs
                                                                                    .ToDictionary(g => g.GuildId, g => g.LogSetting));
                }

                timerReference = new Timer(async(state) =>
                {
                    try
                    {
                        var keys = UserPresenceUpdates.Keys.ToList();

                        await Task.WhenAll(keys.Select(async key =>
                        {
                            List <string> messages;
                            if (UserPresenceUpdates.TryRemove(key, out messages))
                            {
                                try { await key.SendMessageAsync(string.Join(Environment.NewLine, messages)); } catch { }
                            }
                        }));
                    }
                    catch (Exception ex)
                    {
                        _log.Warn(ex);
                    }
                }, null, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10));

                sw.Stop();
                _log.Debug($"Loaded in {sw.Elapsed.TotalSeconds:F2}s");

                //_client.MessageReceived += _client_MessageReceived;
                _client.MessageUpdated        += _client_MessageUpdated;
                _client.MessageDeleted        += _client_MessageDeleted;
                _client.UserBanned            += _client_UserBanned;
                _client.UserUnbanned          += _client_UserUnbanned;
                _client.UserJoined            += _client_UserJoined;
                _client.UserLeft              += _client_UserLeft;
                _client.UserPresenceUpdated   += _client_UserPresenceUpdated;
                _client.UserVoiceStateUpdated += _client_UserVoiceStateUpdated;
                _client.UserVoiceStateUpdated += _client_UserVoiceStateUpdated_TTS;
                _client.UserUpdated           += _client_UserUpdated;

                _client.ChannelCreated   += _client_ChannelCreated;
                _client.ChannelDestroyed += _client_ChannelDestroyed;
                _client.ChannelUpdated   += _client_ChannelUpdated;

                MuteCommands.UserMuted   += MuteCommands_UserMuted;
                MuteCommands.UserUnmuted += MuteCommands_UserUnmuted;
            }
Example #6
0
            private static async void _client_UserPresenceUpdated(Optional <SocketGuild> optGuild, SocketUser usr, SocketPresence before, SocketPresence after)
            {
                try
                {
                    var guild = optGuild.IsSpecified ? optGuild.Value : null;

                    if (guild == null)
                    {
                        return;
                    }

                    LogSetting logSetting;
                    if (!GuildLogSettings.TryGetValue(guild.Id, out logSetting) ||
                        (logSetting.LogUserPresenceId == null) ||
                        before.Status == after.Status)
                    {
                        return;
                    }

                    ITextChannel logChannel;
                    if ((logChannel = await TryGetLogChannel(guild, logSetting, LogType.UserPresence)) == null)
                    {
                        return;
                    }
                    string str;
                    if (before.Status != after.Status)
                    {
                        str = $"🔵`{prettyCurrentTime}`👤__**{usr.Username}**__ is now **{after.Status}**.";
                    }
                    else
                    {
                        str = $"👾`{prettyCurrentTime}`👤__**{usr.Username}**__ is now playing **{after.Game}**.";
                    }

                    UserPresenceUpdates.AddOrUpdate(logChannel, new List <string>()
                    {
                        str
                    }, (id, list) => { list.Add(str); return(list); });
                }
                catch { }
            }