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();
        }
        public async Task InitializeCurrentUser(Update update)
        {
            int  userTelegramId;
            long chatId;

            switch (update.Type)
            {
            case UpdateType.Message:
                userTelegramId = update.Message.From.Id;
                chatId         = update.Message.Chat.Id;
                break;

            case UpdateType.CallbackQuery:
                userTelegramId = update.CallbackQuery.From.Id;
                chatId         = update.CallbackQuery.Message.Chat.Id;
                break;

            case UpdateType.EditedMessage:
                userTelegramId = update.EditedMessage.From.Id;
                chatId         = update.EditedMessage.Chat.Id;
                break;

            default:
                throw new CurrentUserInitializationException($"Unknown telegram update type: {update.Type}");
            }

            TelegramRozkladUser telegramRozkladUser = null;

            try
            {
                telegramRozkladUser = await _telegramRozkladUserDao.FindByTelegramId(userTelegramId);

                if (telegramRozkladUser == null)
                {
                    telegramRozkladUser = new TelegramRozkladUser
                    {
                        TelegramId = userTelegramId,
                        Language   = _localizationService.DefaultLanguage
                    };

                    await _telegramRozkladUserDao.Add(telegramRozkladUser);
                }

                if (telegramRozkladUser.IsDeleted)
                {
                    telegramRozkladUser.IsDeleted = false;

                    await _telegramRozkladUserDao.Update(telegramRozkladUser);
                }

                _currentTelegramUserContext.TelegramRozkladUser = telegramRozkladUser;
                _currentTelegramUserContext.ChatId = chatId;
            }
            catch (Exception e)
            {
                var outE = new CurrentUserInitializationException("Error when getting user", e);

                var telegramRozkladUserId = telegramRozkladUser?.TelegramId;
                _logger.LogError(TelegramLogEvents.UserInitializationError, outE,
                                 "userTelegramId = {userTelegramId}. " +
                                 "chatId = {chatId}. " +
                                 "TelegramRozkladUser telegram id = {telegramRozkladUserId}",
                                 userTelegramId, chatId, telegramRozkladUserId);

                throw outE;
            }
        }
Beispiel #3
0
        public async Task <bool> Handle(LongLastingUserActionArguments userActionArguments)
        {
            string userInput = null;
            ICollection <Group> facultyGroups = null;
            Group facultyGroup = null;

            try
            {
                userInput = (userActionArguments.Parameters[typeof(Message)] as Message)?.Text;

                if (string.IsNullOrWhiteSpace(userInput))
                {
                    await _telegramBotActions.ShowMessage(o => o.ShowIncorrectInputMessage = true);

                    return(true);
                }

                if (userInput == _currentUserLocalizationService["back"])
                {
                    await _telegramBotActions.ShowTimetableSelectingFacultyMenu();

                    return(true);
                }

                facultyGroups = await GetFacultyGroups(userActionArguments);

                facultyGroup = facultyGroups.FirstOrDefault(f => f.Name == userInput);

                if (facultyGroup == null)
                {
                    await _telegramBotActions.ShowMessage(o =>
                                                          o.MessageTextLocalizationValue = "such-faculty-group-was-not-found");

                    return(true);
                }

                var currentTelegramUser = userActionArguments.TelegramRozkladUser;

                currentTelegramUser.FacultyGroups.Add(facultyGroup);
                await _telegramRozkladUserDao.Update(currentTelegramUser);

                await _longLastingUserActionManager.ClearUserAction(currentTelegramUser);

                await _telegramBotActions.ShowMainMenu(new ShowMainMenuOptions
                {
                    LocalizationValueToShow = "faculty-group-has-been-added"
                });

                return(true);
            }
            catch (Exception e)
            {
                var facultyGroupsString = string.Empty;

                if (facultyGroups != null)
                {
                    facultyGroupsString = string.Join(",", facultyGroups.Select(f => f.ToString()));
                }

                _logger.LogError(TelegramLogEvents.TimetableSelectingFacultyGroupToAddError, e,
                                 "userInput: {userInput}. " +
                                 "facultyGroups: {facultyGroupsString}. " +
                                 "facultyGroup: {facultyGroup}. " +
                                 "userActionArguments: {userActionArguments}",
                                 userInput, facultyGroupsString, facultyGroup, userActionArguments);

                throw;
            }
        }