Example #1
0
        public static async Task ClientOnGuildAvailable(DiscordClient client, GuildCreateEventArgs e)
        {
            await Bot.UpdateBotStatusAsync(client, e.Guild);

            try
            {
                VoiceListener.ReadFindChannelMesages();
            }
            catch { }

            foreach (var entry in e.Guild.VoiceStates.Where(x => x.Value.Channel != null && x.Value.Channel.Id != e.Guild.AfkChannel.Id).ToList())
            {
                if (!VoiceListener.VoiceTimeCounters.ContainsKey(entry.Key))
                {
                    VoiceListener.VoiceTimeCounters.Add(entry.Key, DateTime.Now);
                }
            }
        }
Example #2
0
        public static async Task ClientOnMessageReactionAdded(DiscordClient client, MessageReactionAddEventArgs e)
        {
            var discordUser = await client.GetUserAsync(e.User.Id);

            if (discordUser.IsBot)
            {
                return;
            }

            //Проверка если сообщение с принятием правил сообщества
            if (e.Message.Id == Bot.BotSettings.CodexMessageId && e.Emoji.GetDiscordName() == ":white_check_mark:")
            {
                //При надобности добавить кулдаун

                /*if (EmojiCooldowns.ContainsKey(e.User)) // проверка на кулдаун
                 *  if ((EmojiCooldowns[e.User] - DateTime.Now).Seconds > 0) return;
                 *
                 * // если проверка успешно пройдена, добавим пользователя
                 * // в словарь кулдаунов
                 * EmojiCooldowns[e.User] = DateTime.Now.AddSeconds(Bot.BotSettings.FastCooldown);*/

                //Проверка на purge
                var       hasPurge   = false;
                ReportSQL validPurge = null;
                foreach (var purge in ReportSQL.GetForUser(discordUser.Id, ReportType.CodexPurge))
                {
                    if (purge.ReportEnd > DateTime.Now)
                    {
                        validPurge = purge;
                        hasPurge   = true;
                        break;
                    }
                }

                if (hasPurge)
                {
                    var moderator = await e.Channel.Guild.GetMemberAsync(validPurge.Moderator);

                    try
                    {
                        await(await e.Guild.GetMemberAsync(discordUser.Id)).SendMessageAsync(
                            "**Возможность принять правила заблокирована**\n" +
                            $"**Снятие через:** {Utility.FormatTimespan(DateTime.Now - validPurge.ReportEnd)}\n" +
                            $"**Модератор:** {moderator.Username}#{moderator.Discriminator}\n" +
                            $"**Причина:** {validPurge.Reason}\n");
                    }

                    catch (UnauthorizedException)
                    {
                        //user can block the bot
                    }
                    return;
                }

                //Выдаем роль правил
                var member = await e.Guild.GetMemberAsync(discordUser.Id);

                //Проверка времени входа на сервер.
                if (member.JoinedAt > DateTime.Now.AddMinutes(-10))
                {
                    try
                    {
                        await member.SendMessageAsync(
                            $"{Bot.BotSettings.ErrorEmoji} Для принятия правил вы должны находиться на сервере минимум " +
                            $"**{Utility.FormatTimespan(TimeSpan.FromMinutes(10))}**.");

                        await e.Message.DeleteReactionAsync(DiscordEmoji.FromName(client, ":white_check_mark:"), member);
                    }
                    catch (UnauthorizedException) { }
                    return;
                }

                if (!member.Roles.Contains(e.Channel.Guild.GetRole(Bot.BotSettings.CodexRole)))
                {
                    //Выдаем роль правил
                    await member.GrantRoleAsync(e.Channel.Guild.GetRole(Bot.BotSettings.CodexRole));

                    //Убираем роль блокировки правил
                    await member.RevokeRoleAsync(e.Channel.Guild.GetRole(Bot.BotSettings.PurgeCodexRole));

                    client.Logger.LogInformation(BotLoggerEvents.Event, $"Пользователь {discordUser.Username}#{discordUser.Discriminator} ({discordUser.Id}) подтвердил прочтение правил через реакцию.");
                }

                return;
            }

            //Проверка если сообщение с принятием правил рейда
            if (e.Message.Id == Bot.BotSettings.FleetCodexMessageId && e.Emoji.GetDiscordName() == ":white_check_mark:")
            {
                //Проверка на purge
                var       hasPurge   = false;
                ReportSQL validPurge = null;
                foreach (var purge in ReportSQL.GetForUser(discordUser.Id, ReportType.FleetPurge))
                {
                    if (purge.ReportEnd > DateTime.Now)
                    {
                        validPurge = purge;
                        hasPurge   = true;
                        break;
                    }
                }

                if (hasPurge)
                {
                    var moderator = await e.Channel.Guild.GetMemberAsync(validPurge.Moderator);

                    try
                    {
                        await(await e.Guild.GetMemberAsync(discordUser.Id)).SendMessageAsync(
                            "**Возможность принять правила заблокирована**\n" +
                            $"**Снятие через:** {Utility.FormatTimespan(DateTime.Now - validPurge.ReportEnd)}\n" +
                            $"**Модератор:** {moderator.Username}#{moderator.Discriminator}\n" +
                            $"**Причина:** {validPurge.Reason}\n");
                    }

                    catch (UnauthorizedException)
                    {
                        //user can block the bot
                    }
                    return;
                } //Удаляем блокировку если истекла

                var member = await e.Guild.GetMemberAsync(discordUser.Id);

                //Проверка времени входа на сервер.
                if (member.JoinedAt > DateTime.Now.AddDays(-Bot.BotSettings.FleetDateOffset))
                {
                    await member.SendMessageAsync(
                        $"{Bot.BotSettings.ErrorEmoji} Для получения доступа к рейдам вы должны находиться на сервере " +
                        $"**{Utility.FormatTimespan(TimeSpan.FromDays(Bot.BotSettings.FleetDateOffset))}**.");

                    await e.Message.DeleteReactionAsync(DiscordEmoji.FromName(client, ":white_check_mark:"), member);

                    return;
                }

                var voiceTime = VoiceListener.GetUpdatedVoiceTime(e.User.Id);
                //Проверка на время проведенное в голосовых каналах
                if (voiceTime < TimeSpan.FromHours(Bot.BotSettings.FleetVoiceTimeOffset))
                {
                    await member.SendMessageAsync(
                        $"{Bot.BotSettings.ErrorEmoji} Для получения доступа к рейдам вы должны провести " +
                        $"**{Utility.FormatTimespan(TimeSpan.FromHours(Bot.BotSettings.FleetVoiceTimeOffset))}** в голосовых каналах. " +
                        $"Ваше время: **{Utility.FormatTimespan(voiceTime)}**");

                    await e.Message.DeleteReactionAsync(DiscordEmoji.FromName(client, ":white_check_mark:"), member);

                    return;
                }

                //Проверка на регистрацию и привязку Xbox

                var webUser = WebUser.GetByDiscordId(member.Id);
                if (webUser == null)
                {
                    await member.SendMessageAsync(
                        $"{Bot.BotSettings.ErrorEmoji} Для получения доступа к рейдам вам нужно авторизоваться с помощью Discord на сайте {Bot.BotSettings.WebURL}login.");

                    await e.Message.DeleteReactionAsync(DiscordEmoji.FromName(client, ":white_check_mark:"), member);

                    return;
                }

                if (webUser.LastXbox == "")
                {
                    await member.SendMessageAsync($"{Bot.BotSettings.ErrorEmoji} Для получения доступа к рейдам вы должны привязать Xbox к своему аккаунту, затем перейдите по ссылке " +
                                                  $"{Bot.BotSettings.WebURL}xbox - это обновит базу данных.");

                    await e.Message.DeleteReactionAsync(DiscordEmoji.FromName(client, ":white_check_mark:"), member);

                    return;
                }

                // Проверка ЧС

                if (BlacklistEntry.IsBlacklisted(member.Id) || BlacklistEntry.IsBlacklistedXbox(webUser.LastXbox))
                {
                    await member.SendMessageAsync(
                        $"{Bot.BotSettings.ErrorEmoji} Вы находитесь в чёрном списке рейдов и вам навсегда ограничен доступ к ним.");

                    return;
                }

                //Выдаем роль правил рейда
                if (!member.Roles.Any(x => x.Id == Bot.BotSettings.FleetCodexRole))
                {
                    await member.GrantRoleAsync(e.Channel.Guild.GetRole(Bot.BotSettings.FleetCodexRole));

                    await e.Guild.GetChannel(Bot.BotSettings.FleetLogChannel)
                    .SendMessageAsync($"{DiscordEmoji.FromName(client, ":new:")} Пользователь **{e.User.Username}#{e.User.Discriminator}** ({e.User.Id}) получил роль рейда. **Xbox:** {webUser.LastXbox}.");

                    client.Logger.LogInformation(BotLoggerEvents.Event, $"Пользователь {discordUser.Username}#{discordUser.Discriminator} ({discordUser.Id}) подтвердил прочтение правил рейда.");
                }

                return;
            }

            //Проверка на сообщение эмиссарства
            if (e.Message.Id == Bot.BotSettings.EmissaryMessageId)
            {
                await e.Message.DeleteReactionAsync(e.Emoji, discordUser);

                if (EmojiCooldowns.ContainsKey(discordUser)) // проверка на кулдаун
                {
                    if ((EmojiCooldowns[discordUser] - DateTime.Now).Seconds > 0)
                    {
                        return;
                    }
                }

                // если проверка успешно пройдена, добавим пользователя
                // в словарь кулдаунов
                EmojiCooldowns[discordUser] = DateTime.Now.AddSeconds(Bot.BotSettings.FastCooldown);

                //Проверка у пользователя уже существующих ролей эмисарства и их удаление
                var member = await e.Guild.GetMemberAsync(discordUser.Id);

                member.Roles.Where(x => x.Id == Bot.BotSettings.EmissaryGoldhoadersRole ||
                                   x.Id == Bot.BotSettings.EmissaryTradingCompanyRole ||
                                   x.Id == Bot.BotSettings.EmissaryOrderOfSoulsRole ||
                                   x.Id == Bot.BotSettings.EmissaryAthenaRole ||
                                   x.Id == Bot.BotSettings.EmissaryReaperBonesRole ||
                                   x.Id == Bot.BotSettings.HuntersRole).ToList()
                .ForEach(async x => await member.RevokeRoleAsync(x));

                //Выдаем роль в зависимости от реакции
                switch (e.Emoji.GetDiscordName())
                {
                case ":moneybag:":
                    await member.GrantRoleAsync(e.Channel.Guild.GetRole(Bot.BotSettings.EmissaryGoldhoadersRole));

                    break;

                case ":pig:":
                    await member.GrantRoleAsync(e.Channel.Guild.GetRole(Bot.BotSettings.EmissaryTradingCompanyRole));

                    break;

                case ":skull:":
                    await member.GrantRoleAsync(e.Channel.Guild.GetRole(Bot.BotSettings.EmissaryOrderOfSoulsRole));

                    break;

                case ":gem:":
                    await member.GrantRoleAsync(e.Channel.Guild.GetRole(Bot.BotSettings.EmissaryAthenaRole));

                    break;

                case ":skull_crossbones:":
                    await member.GrantRoleAsync(e.Channel.Guild.GetRole(Bot.BotSettings.EmissaryReaperBonesRole));

                    break;

                case ":fish:":
                    await member.GrantRoleAsync(e.Channel.Guild.GetRole(Bot.BotSettings.HuntersRole));

                    break;

                default:
                    break;
                }
                //Отправка в лог
                client.Logger.LogInformation(BotLoggerEvents.Event, $"{discordUser.Username}#{discordUser.Discriminator} получил новую роль эмиссарства.");

                return;
            }

            if (e.Message.Channel != null)
            {
                //Проверка на голосование
                if (e.Message.Channel.Id == Bot.BotSettings.VotesChannel)
                {
                    var vote = Vote.GetByMessageId(e.Message.Id);

                    await e.Message.DeleteReactionAsync(e.Emoji, discordUser);

                    // Проверка на окончание голосования
                    if (DateTime.Now > vote.End)
                    {
                        return;
                    }

                    // Проверка на предыдущий голос
                    if (vote.Voters.ContainsKey(discordUser.Id))
                    {
                        return;
                    }

                    if (e.Emoji.GetDiscordName() == ":white_check_mark:")
                    {
                        vote.Voters.Add(discordUser.Id, true);
                        ++vote.Yes;
                    }
                    else
                    {
                        vote.Voters.Add(discordUser.Id, false);
                        ++vote.No;
                    }

                    var total = vote.Voters.Count;

                    var author = await e.Guild.GetMemberAsync(vote.Author);

                    var embed = Utility.GenerateVoteEmbed(
                        author,
                        DiscordColor.Yellow,
                        vote.Topic,
                        vote.End,
                        vote.Voters.Count,
                        vote.Yes,
                        vote.No,
                        vote.Id);

                    Vote.Save(Bot.BotSettings.VotesXML);

                    await e.Message.ModifyAsync(embed : embed);

                    await(await e.Guild.GetMemberAsync(discordUser.Id)).SendMessageAsync($"{Bot.BotSettings.OkEmoji} Спасибо, ваш голос учтён!");
                }

                // Private ship confirmation message
                if (e.Channel.Id == Bot.BotSettings.PrivateRequestsChannel)
                {
                    var ship = PrivateShip.GetByRequest(e.Message.Id);
                    if (ship != null && ship.Channel == 0)
                    {
                        if (e.Emoji == DiscordEmoji.FromName(client, ":white_check_mark:"))
                        {
                            var channel = await e.Guild.CreateChannelAsync($"☠{ship.Name}☠", ChannelType.Voice,
                                                                           e.Guild.GetChannel(Bot.BotSettings.PrivateCategory), bitrate : Bot.BotSettings.Bitrate);

                            await channel.AddOverwriteAsync(e.Guild.GetRole(Bot.BotSettings.CodexRole),
                                                            Permissions.AccessChannels);

                            await channel.AddOverwriteAsync(e.Guild.EveryoneRole, Permissions.None, Permissions.UseVoice);

                            ship.Channel   = channel.Id;
                            ship.CreatedAt = DateTime.Now;
                            ship.LastUsed  = DateTime.Now;

                            var captain = (from member in ship.GetMembers()
                                           where member.Role == PrivateShipMemberRole.Captain
                                           select member).First();
                            var captainMember = await e.Guild.GetMemberAsync(captain.MemberId);

                            await channel.AddOverwriteAsync(captainMember, Permissions.UseVoice);

                            captain.Status = true;

                            await e.Channel.SendMessageAsync(
                                $"{Bot.BotSettings.OkEmoji} Администратор {e.User.Mention} подтвердил запрос на создание " +
                                $"корабля **{ship.Name}**.");

                            try
                            {
                                await captainMember.SendMessageAsync(
                                    $"{Bot.BotSettings.OkEmoji} Администратор **{e.User.Username}#{e.User.Discriminator}** " +
                                    $"подтвердил твой запрос на создание корабля **{ship.Name}**.");
                            }
                            catch (UnauthorizedException)
                            {
                            }
                        }
                        else if (e.Emoji == DiscordEmoji.FromName(client, ":no_entry:"))
                        {
                            var captain = (from member in ship.GetMembers()
                                           where member.Role == PrivateShipMemberRole.Captain
                                           select member).First();
                            var captainMember = await e.Guild.GetMemberAsync(captain.MemberId);

                            PrivateShip.Delete(ship.Name);
                            await e.Channel.SendMessageAsync(
                                $"{Bot.BotSettings.OkEmoji} Администратор {e.User.Mention} отклонил запрос на создание " +
                                $"корабля **{ship.Name}**.");

                            try
                            {
                                await captainMember.SendMessageAsync(
                                    $"{Bot.BotSettings.ErrorEmoji} Администратор **{e.User.Username}#{e.User.Discriminator}** " +
                                    $"отклонил твой запрос на создание корабля **{ship.Name}**.");
                            }
                            catch (UnauthorizedException)
                            {
                            }
                        }

                        await e.Message.DeleteAllReactionsAsync();
                    }
                }
            }
        }
Example #3
0
        /// <summary>
        ///     Очистка сообщений из каналов
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static async void ClearChannelMessagesOnElapsed(object sender, ElapsedEventArgs e)
        {
            Client.Logger.LogDebug(BotLoggerEvents.Timers, $"ClearChannelMessagesOnElapsed running");

            try
            {
                var guild = Client.Guilds[Bot.BotSettings.Guild];

                var channels = new Dictionary <DiscordChannel, TimeSpan>
                {
                    { guild.GetChannel(Bot.BotSettings.FindChannel), new TimeSpan(0, 30, 0) },           //30 минут для канала поиска
                    { guild.GetChannel(Bot.BotSettings.FleetCreationChannel), new TimeSpan(24, 0, 0) }   //24 часа для канала создания рейда
                };

                foreach (var channel in channels)
                {
                    try
                    {
                        var messages = await channel.Key.GetMessagesAsync();

                        var toDelete = messages.ToList()
                                       .Where(x => !x.Pinned).ToList()                                  //Не закрепленные сообщения
                                       .Where(x =>
                        {
                            if (x.IsEdited && x.Embeds.Count() != 0 &&
                                x.Embeds.FirstOrDefault().Footer.Text.Contains("заполнен"))
                            {
                                return(DateTimeOffset.Now.Subtract(x.EditedTimestamp.Value.Add(new TimeSpan(0, 5, 0))).TotalSeconds > 0);
                            }
                            else
                            {
                                return(DateTimeOffset.Now.Subtract(x.CreationTimestamp.Add(channel.Value)).TotalSeconds > 0);
                            }
                        });         //Опубликованные ранее определенного времени

                        //Clear FindChannelInvites from deleted messages
                        foreach (var message in toDelete)
                        {
                            if (VoiceListener.FindChannelInvites.ContainsValue(message.Id))
                            {
                                VoiceListener.FindChannelInvites.Remove(VoiceListener.FindChannelInvites.FirstOrDefault(x => x.Value == message.Id).Key);
                                await VoiceListener.SaveFindChannelMessagesAsync();
                            }
                        }

                        if (toDelete.Count() > 0)
                        {
                            await channel.Key.DeleteMessagesAsync(toDelete);

                            Client.Logger.LogInformation(BotLoggerEvents.Timers, $"Канал {channel.Key.Name} был очищен.");
                        }
                    }
                    catch (Exception ex)
                    {
                        Client.Logger.LogWarning(BotLoggerEvents.Timers, ex, $"Ошибка при удалении сообщений в {channel.Key.Name}.", DateTime.Now);
                    }
                }
            }
            catch (Exception ex)
            {
                Client.Logger.LogError(BotLoggerEvents.Timers, ex, $"Ошибка при удалении сообщений в каналах.");
            }
        }