Ejemplo n.º 1
0
        public async Task DeleteAsync(UpdateMessage message)
        {
            var callbackQueryData = message.CallbackQuery.Data.Split(';');
            var occasionId        = callbackQueryData[1];
            var messageId         = message.CallbackQuery.Message.MessageId.ToString();

            var occasion = _occasionRepository.Find(x => x.RowKey == occasionId).FirstOrDefault();

            if (occasion == null)
            {
                return;
            }

            await _occasionRepository.DeleteAsync(occasion);

            var occasionsToDelete           = _occasionRepository.GetByChatId(occasion.ChatId).ToList();
            var updateDeleteOccasionMessage = TelegramMessageFactory.UpdateDeleteOccasionMessage(occasion.ChatId,
                                                                                                 messageId,
                                                                                                 occasionsToDelete);
            await _telegramClient.EditMessageText(updateDeleteOccasionMessage);

            await _telegramClient.AnswerCallbackQuery(new AnswerCallbackQuery
            {
                CallBackQueryId = message.CallbackQuery.Id,
                Text            = Messages.OccasionDeleted
            });
        }
Ejemplo n.º 2
0
        public async Task GetOccasionsToStartAsync(UpdateMessage message)
        {
            var chatId = message.Message.Chat.Id;
            var fromId = message.Message.From.Id.ToString();

            var isAdmin = await _telegramClient.IsAdminAsync(chatId, fromId);

            if (!isAdmin)
            {
                await _telegramClient.SendMessageAsync(new SendMessage
                {
                    ChatId = chatId,
                    Text   = Messages.OnlyAdminCanDoThis,
                });

                return;
            }

            var occasions = _occasionRepository.GetByChatId(chatId).ToList();

            if (!occasions.Any())
            {
                await _telegramClient.SendMessageAsync(new SendMessage
                {
                    ChatId = chatId,
                    Text   = Messages.NoOccasionsToStart
                });

                return;
            }

            var sendMessage = TelegramMessageFactory.CreateStartOccasionMessage(chatId, occasions);
            await _telegramClient.SendMessageAsync(sendMessage);
        }
Ejemplo n.º 3
0
        public async Task StopAllActivePollsAsync(UpdateMessage message)
        {
            var chatId = message.Message.Chat.Id;
            var fromId = message.Message.From.Id.ToString();

            var isAdmin = await _telegramClient.IsAdminAsync(chatId, fromId);

            if (!isAdmin)
            {
                await _telegramClient.SendMessageAsync(new SendMessage
                {
                    ChatId = chatId,
                    Text   = Messages.OnlyAdminCanDoThis,
                });

                return;
            }

            var activePolls = _pollRepository.Find(x => x.ChatId == chatId && !x.IsClosed).ToList();

            if (!activePolls.Any())
            {
                await _telegramClient.SendMessageAsync(new SendMessage
                {
                    ChatId = chatId,
                    Text   = Messages.NoActivePollRunning
                });

                return;
            }

            var occasions = _occasionRepository.GetByChatId(chatId).ToList();

            foreach (var activePoll in activePolls)
            {
                var stopPollMessage =
                    TelegramMessageFactory.CreateStopPollMessage(activePoll.ChatId, activePoll.MessageId);
                await _telegramClient.StopPollAsync(stopPollMessage);

                activePoll.IsClosed = true;
                await _pollRepository.UpdateAsync(activePoll);

                var pollOccasion = occasions.FirstOrDefault(x => x.RowKey == activePoll.OccasionId);
                if (pollOccasion == null)
                {
                    continue;
                }

                await _telegramClient.SendMessageAsync(new SendMessage
                {
                    ChatId = chatId,
                    Text   = string.Format(Messages.ActivePollStopped, pollOccasion.Name)
                });
            }
        }
Ejemplo n.º 4
0
        public async Task HandleAsync_should_call_correct_handler_when_type_is_Text()
        {
            var fakeTextMessageHandler = new Mock <IHandleTelegramTextMessage>();
            var fakeLogger             = new Mock <ILogger <TelegramMessageHandler> >();

            var message = TelegramMessageFactory.CreateFakeTelegramMessage(MessageType.Text);

            var messageHandler = new TelegramMessageHandler(fakeLogger.Object, fakeTextMessageHandler.Object);

            await messageHandler.HandleAsync(message);

            fakeTextMessageHandler.Verify(x => x.HandleAsync(It.IsAny <TelegramTextMessage>()), Times.Once);
        }
Ejemplo n.º 5
0
        public async Task HandleAsync_should_do_nothing_if_type_is(MessageType type)
        {
            var fakeTextMessageHandler = new Mock <IHandleTelegramTextMessage>();
            var fakeLogger             = new Mock <ILogger <TelegramMessageHandler> >();

            var message = TelegramMessageFactory.CreateFakeTelegramMessage(type);

            var messageHandler = new TelegramMessageHandler(fakeLogger.Object, fakeTextMessageHandler.Object);

            await messageHandler.HandleAsync(message);

            fakeTextMessageHandler.VerifyNoOtherCalls();
        }
Ejemplo n.º 6
0
        public async Task StartAsync(UpdateMessage message)
        {
            var callbackQueryData = message.CallbackQuery.Data.Split(';');
            var occasionId        = callbackQueryData[1];

            var occasion = _occasionRepository.FindById(occasionId);

            if (occasion == null)
            {
                return;
            }

            var activePolls = _pollRepository.Find(x => x.ChatId == occasion.ChatId && !x.IsClosed).ToList();

            if (activePolls.Any())
            {
                await _telegramClient.SendMessageAsync(new SendMessage
                {
                    ChatId = occasion.ChatId,
                    Text   = Messages.ActivePollRunning
                });

                return;
            }

            var sendPollMessage = TelegramMessageFactory.CreateSendPollMessage(occasion.ChatId, occasion.Name);
            var pollMessage     = await _telegramClient.SendPollAsync(sendPollMessage);

            var entity = new PollEntity
            {
                PartitionKey = occasion.ChatId,
                RowKey       = pollMessage.Poll.Id,
                Timestamp    = _dateTimeService.TableEntityTimeStamp,
                ChatId       = occasion.ChatId,
                OccasionId   = occasionId,
                MessageId    = pollMessage.MessageId.ToString(),
                IsClosed     = false
            };

            await _pollRepository.CreateAsync(entity);

            await _telegramClient.AnswerCallbackQuery(new AnswerCallbackQuery
            {
                CallBackQueryId = message.CallbackQuery.Id,
                Text            = Messages.PollStarted
            });
        }