public async Task Handle(CallbackQueryData callbackQueryData)
        {
            await HandleImplementation(callbackQueryData).ConfigureAwait(false);

            await TelegramBotService.Client.AnswerCallbackQueryAsync(callbackQueryData.CallbackQueryId)
            .ConfigureAwait(false);
        }
        internal static CallbackQueryData DeserializeCallbackQueryData(string callbackQueryDataString)
        {
            var values            = callbackQueryDataString.Split(new[] { S }, StringSplitOptions.RemoveEmptyEntries);
            var callbackQueryData = new CallbackQueryData
            {
                CallbackQueryActionType = (CallbackQueryActionType)int.Parse(values[0]),
                Values = new string[values.Length - 1]
            };

            for (var i = 1; i < values.Length; i++)
            {
                callbackQueryData.Values[i - 1] = values[i];
            }

            return(callbackQueryData);
        }
Example #3
0
        protected override async Task HandleImplementation(CallbackQueryData callbackQueryData)
        {
            _callbackQueryData = callbackQueryData;
            ProcessCallbackQueryData();
            await GetFaculty();
            await GetFacultyGroup();


            var actionOptions = new ShowTimetableFacultyGroupViewMenuOptions
            {
                FacultyGroup       = _facultyGroup,
                DayOfWeek          = _dayOfWeek,
                IsNextWeekSelected = _isNextWeek
            };

            await _botActions.ShowTimetableFacultyGroupViewMenu(actionOptions);
        }
        protected override async Task HandleImplementation(CallbackQueryData callbackQueryData)
        {
            _callbackQueryData = callbackQueryData;
            ProcessCallbackQueryData();

            await GetFaculty();
            await GetFacultyGroup();

            var currentDayOfWeek = _localDateService.LocalDateTime.DayOfWeek;

            var actionOptions = new ShowTimetableFacultyGroupViewMenuOptions
            {
                FacultyGroup       = _facultyGroup,
                DayOfWeek          = currentDayOfWeek,
                IsNextWeekSelected = false
            };

            await _telegramBotActions.ShowTimetableFacultyGroupViewMenu(actionOptions);
        }
        public override async Task Execute(CallbackQuery query)
        {
            var queryData = new CallbackQueryData(query.Data);

            if (query.From.Id != queryData.UserId)
            {
                var expectedChatMember = await DevSilenceKeeper.BotClient.GetChatMemberAsync(query.Message.Chat.Id, queryData.UserId);

                await DevSilenceKeeper.BotClient.AnswerCallbackQueryAsync(
                    query.Id,
                    $"Эту кнопку должен нажать определенный участник чата — {expectedChatMember.User}.",
                    true);

                return;
            }

            var unmutePermissions = new ChatPermissions
            {
                CanSendMessages       = true,
                CanSendMediaMessages  = true,
                CanSendOtherMessages  = true,
                CanSendPolls          = true,
                CanAddWebPagePreviews = true,
                CanInviteUsers        = true
            };

            await DevSilenceKeeper.BotClient.RestrictChatMemberAsync(
                query.Message.Chat.Id,
                query.From.Id,
                unmutePermissions,
                DateTime.Now);

            DevSilenceKeeper.BotClient.SendTextMessageAsync(
                query.Message.Chat.Id,
                $"[{query.From}](tg://user?id={query.From.Id}) теперь ты полноценный участник чата!",
                ParseMode.Markdown)
            .Wait();

            await DevSilenceKeeper.BotClient.DeleteMessageAsync(
                query.Message.Chat.Id,
                query.Message.MessageId);
        }
        protected override async Task HandleImplementation(CallbackQueryData callbackQueryData)
        {
            _callbackQueryData = callbackQueryData;
            ProcessCallbackQueryData();

            var currentUser          = _currentTelegramUserProvider.GetCurrentTelegramRozkladUser();
            var facultyGroupToRemove =
                currentUser.FacultyGroups
                .FirstOrDefault(g =>
                                g.TypeId == _facultyGroupTypeId &&
                                g.Faculty.TypeId == _facultyTypeId);

            if (facultyGroupToRemove != null)
            {
                currentUser.FacultyGroups.Remove(facultyGroupToRemove);
                await _telegramRozkladUserDao.Update(currentUser);
            }

            await _botActions.ShowTimetableFacultyGroupsRemoveMenu();
        }
Example #7
0
        public virtual bool Contains(CallbackQuery query)
        {
            var queryData = new CallbackQueryData(query.Data);

            return(Triggers.Any(trigger => queryData.Trigger == trigger));
        }
Example #8
0
        public override async Task Execute(Message message)
        {
            var tasks = new List <Task>();

            foreach (var newChatMember in message.NewChatMembers)
            {
                if (await newChatMember.IsMuted(message.Chat.Id))
                {
                    var chatMember = await DevSilenceKeeper.BotClient.GetChatMemberAsync(message.Chat.Id, newChatMember.Id);

                    string replyText =
                        $"С возвращением в чат! Ты ещё в муте до {chatMember.UntilDate:dd.MM.yyyy HH:mm:ss} (UTC+02:00)";
                    await DevSilenceKeeper.BotClient.SendTextMessageAsync(
                        message.Chat.Id,
                        replyText,
                        replyToMessageId : message.MessageId);

                    return;
                }

                await DevSilenceKeeper.BotClient.RestrictChatMemberAsync(
                    message.Chat.Id,
                    newChatMember.Id,
                    new ChatPermissions { CanSendMessages = false },
                    DateTime.Now);

                var callbackData = new CallbackQueryData
                {
                    UserId  = newChatMember.Id,
                    Trigger = "verified"
                };
                var captchaMarkup = new InlineKeyboardMarkup(
                    new[]
                {
                    InlineKeyboardButton.WithCallbackData("Я не бот", callbackData.ToString())
                });

                var verifyMessage = await DevSilenceKeeper.BotClient.SendTextMessageAsync(
                    message.Chat.Id,
                    $"{newChatMember} Нажми на кнопку, что бы получить возможность отсылать сообщения.",
                    replyToMessageId : message.MessageId,
                    replyMarkup : captchaMarkup);

                tasks.Add(Task.Run(async() =>
                {
                    Thread.Sleep(_timeLimitForVerification);
                    try
                    {
                        var member =
                            await DevSilenceKeeper.BotClient.GetChatMemberAsync(message.Chat.Id, newChatMember.Id);

                        // If somebody else give proved chat member
                        if (member.CanSendMessages == true)
                        {
                            return;
                        }

                        await DevSilenceKeeper.BotClient.DeleteMessageAsync(verifyMessage.Chat.Id,
                                                                            verifyMessage.MessageId);
                        await DevSilenceKeeper.BotClient.SendTextMessageAsync(
                            message.Chat.Id,
                            $"{newChatMember} не прошел проверку на бота, за отведенное время ({_timeLimitForVerification.TotalSeconds} c.) и был кикнут из чата.",
                            replyToMessageId: message.MessageId);
                        await DevSilenceKeeper.BotClient.KickChatMemberAsync(message.Chat.Id, newChatMember.Id);
                        await DevSilenceKeeper.BotClient.UnbanChatMemberAsync(message.Chat.Id, newChatMember.Id);
                    }
                    catch
                    {
                        // User complete verification, because can't delete not existing message
                    }
                }));
            }

            await Task.WhenAll(tasks.ToArray());
        }
 protected override Task HandleImplementation(CallbackQueryData callbackQueryData)
 {
     return(_botActions.ShowTimetableFacultyGroupsMenu());
 }
 protected abstract Task HandleImplementation(CallbackQueryData callbackQueryData);