Esempio n. 1
0
        private async void BotOnMessageAsync(object sender, MessageEventArgs messageEventArgs)
        {
            var message = messageEventArgs.Message;

            if (message == null || message.Type != MessageType.Text)
            {
                return;
            }

            var chatId = message.Chat.Id;
            var firstWordOfReceivedMessage = message.Text.Split().First();

            if (keyboardMessageIdByChatId.ContainsKey(chatId))
            {
                await botClient.DeleteMessageAsync(chatId, keyboardMessageIdByChatId[chatId]);

                keyboardMessageIdByChatId.Remove(chatId);
                previousCommandByChatId.Remove(chatId);
            }

            if (BotCommandByRepresent.ContainsKey(firstWordOfReceivedMessage))
            {
                selectedToEditDayByChatId.Remove(chatId);

                var receivedCommandType = BotCommandByRepresent[firstWordOfReceivedMessage];

                switch (receivedCommandType)
                {
                case BotCommand.Today:
                    var today = message.Date.DayOfWeek;
                    await botClient.SendTextMessageAsync(chatId, today == DayOfWeek.Sunday
                                                         ?BotPhrases.OnTodayRequestInSunday
                                                         : schedule.GetDaySchedule(
                                                             (WorkDay)(today - 1)));

                    previousCommandByChatId.Remove(chatId);
                    break;

                case BotCommand.Full:
                    await botClient.SendTextMessageAsync(chatId, schedule.GetFullSchedule());

                    previousCommandByChatId.Remove(chatId);
                    break;

                case BotCommand.SpecificDay:
                    keyboardMessageIdByChatId[chatId] = (await botClient.SendTextMessageAsync(
                                                             chatId, BotPhrases.OnSpecificDayCommand,
                                                             replyMarkup: inlineWorkDaysKeyboard)).MessageId;
                    previousCommandByChatId[chatId] = receivedCommandType;
                    break;

                case BotCommand.EditSchedule:
                    await botClient.SendTextMessageAsync(chatId, BotPhrases.OnEditScheduleRequest);

                    previousCommandByChatId[chatId] = receivedCommandType;
                    break;

                case BotCommand.ClearDaySchedule:
                    await botClient.SendTextMessageAsync(chatId, BotPhrases.OnEditScheduleRequest);

                    previousCommandByChatId[chatId] = receivedCommandType;
                    break;

                case BotCommand.GetAccess:
                    await botClient.SendTextMessageAsync(chatId, BotPhrases.OnAdministrationRequest);

                    previousCommandByChatId[chatId] = receivedCommandType;
                    break;

                case BotCommand.RevokeAccess:
                    await botClient.SendTextMessageAsync(chatId, BotPhrases.OnAdministrationRequest);

                    previousCommandByChatId[chatId] = receivedCommandType;
                    break;
                }
            }
            else if (previousCommandByChatId.ContainsKey(chatId) &&
                     previousCommandByChatId[chatId] != BotCommand.SpecificDay)
            {
                switch (previousCommandByChatId[chatId])
                {
                case BotCommand.EditSchedule when accessTokensStorage.IsValidToken(message.Text):
                    keyboardMessageIdByChatId[chatId] = (await botClient.SendTextMessageAsync(
                                                             chatId, BotPhrases.OnCorrectEditTokenToEdit,
                                                             replyMarkup: inlineWorkDaysKeyboard)).MessageId;

                    break;

                case BotCommand.ClearDaySchedule when accessTokensStorage.IsValidToken(message.Text):
                    keyboardMessageIdByChatId[chatId] = (await botClient.SendTextMessageAsync(
                                                             chatId, BotPhrases.OnCorrectEditTokenToClearDay,
                                                             replyMarkup: inlineWorkDaysKeyboard)).MessageId;

                    break;

                case BotCommand.GetAccess when accessTokensStorage.ApiAccessToken == message.Text:
                    var newAccessToken = AccessTokensHelper.GenerateAccessToken();
                    await botClient.SendTextMessageAsync(
                        chatId, string.Format(BotPhrases.OnCorrectApiTokenToGetEditToken, newAccessToken));

                    accessTokensStorage.StoreAccessToken(newAccessToken);
                    previousCommandByChatId.Remove(chatId);
                    break;

                case BotCommand.RevokeAccess when accessTokensStorage.ApiAccessToken == message.Text:
                    if (accessTokensStorage.IsEmpty)
                    {
                        await botClient.SendTextMessageAsync(
                            chatId, BotPhrases.OnCorrectApiTokenToRemoveEditTokenIfNoTokens);

                        previousCommandByChatId.Remove(chatId);
                    }
                    else
                    {
                        keyboardMessageIdByChatId[chatId] = (await botClient.SendTextMessageAsync(
                                                                 chatId,
                                                                 BotPhrases.OnCorrectApiTokenToRemoveEditToken,
                                                                 replyMarkup: AccessTokensHelper
                                                                 .GetInlineAccessTokensKeyboard(
                                                                     accessTokensStorage)))
                                                            .MessageId;
                    }

                    break;

                default:
                    await botClient.SendTextMessageAsync(chatId, BotPhrases.OnIncorrectEditToken);

                    break;
                }
            }
            else if (selectedToEditDayByChatId.ContainsKey(chatId))
            {
                if (schedule.TrySetDaySchedule(selectedToEditDayByChatId[chatId], message.Text))
                {
                    keyboardMessageIdByChatId[chatId] = (await botClient.SendTextMessageAsync(
                                                             chatId, string.Format(
                                                                 BotPhrases.OnSuccessfullyDayScheduleEdit,
                                                                 RepresentByWorkDay[selectedToEditDayByChatId[chatId]]),
                                                             replyMarkup: inlineWorkDaysKeyboard)).MessageId;

                    previousCommandByChatId[chatId] = BotCommand.EditSchedule;
                    selectedToEditDayByChatId.Remove(chatId);
                }
                else
                {
                    await botClient.SendTextMessageAsync(chatId, BotPhrases.OnUnsuccessfullyDayScheduleEdit);
                }
            }
            else
            {
                previousCommandByChatId.Remove(chatId);
                await botClient.SendTextMessageAsync(chatId, BotPhrases.HelpMessage);
            }
        }
Esempio n. 2
0
        private async void BotOnCallbackQueryAsync(object sender, CallbackQueryEventArgs callbackQueryEventArgs)
        {
            var callbackQuery = callbackQueryEventArgs.CallbackQuery;
            var chatId        = callbackQuery.Message.Chat.Id;

            switch (previousCommandByChatId[chatId])
            {
            case BotCommand.EditSchedule:
                await botClient.DeleteMessageAsync(chatId, keyboardMessageIdByChatId[chatId]);

                keyboardMessageIdByChatId.Remove(chatId);

                await botClient.SendTextMessageAsync(
                    chatId, string.Format(BotPhrases.OnInlineSelectDayToEdit, callbackQuery.Data));

                selectedToEditDayByChatId[callbackQuery.Message.Chat.Id] = workDayByRepresent[callbackQuery.Data];
                previousCommandByChatId.Remove(chatId);
                break;

            case BotCommand.ClearDaySchedule:
                await botClient.DeleteMessageAsync(chatId, keyboardMessageIdByChatId[chatId]);

                keyboardMessageIdByChatId.Remove(chatId);

                schedule.ClearDaySchedule(workDayByRepresent[callbackQuery.Data]);

                await botClient.SendTextMessageAsync(
                    chatId, string.Format(BotPhrases.OnInlineSelectDayToClear, callbackQuery.Data));

                previousCommandByChatId.Remove(chatId);
                break;

            case BotCommand.SpecificDay:
                await botClient.SendTextMessageAsync(
                    chatId, schedule.GetDaySchedule(workDayByRepresent[callbackQuery.Data]));

                break;

            case BotCommand.RevokeAccess:
                await botClient.DeleteMessageAsync(chatId, keyboardMessageIdByChatId[chatId]);

                accessTokensStorage.DeleteAccessToken(callbackQuery.Data);

                if (accessTokensStorage.IsEmpty)
                {
                    await botClient.SendTextMessageAsync(
                        chatId, string.Format(BotPhrases.OnRevokeLastEditToken, callbackQuery.Data));

                    keyboardMessageIdByChatId.Remove(chatId);
                    previousCommandByChatId.Remove(chatId);
                }
                else
                {
                    keyboardMessageIdByChatId[chatId] = (await botClient.SendTextMessageAsync(
                                                             chatId,
                                                             string.Format(
                                                                 BotPhrases.OnRevokeNotLastEditToken,
                                                                 callbackQuery.Data),
                                                             replyMarkup: AccessTokensHelper
                                                             .GetInlineAccessTokensKeyboard(
                                                                 accessTokensStorage)))
                                                        .MessageId;
                }

                break;
            }
        }